Changeset 72 for trunk/src/org/expeditee/items/ItemUtils.java

Timestamp:

05/23/08 09:02:59 (16 years ago)

Author:

ra33

Message:

Added lots of stuff

File:

• trunk/src/org/expeditee/items/ItemUtils.java (modified) (10 diffs)

trunk/src/org/expeditee/items/ItemUtils.java

@@ -13 +13 @@
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
@@ -21 +22 @@
 import org.expeditee.gui.DisplayIO;
 import org.expeditee.gui.Frame;
-import org.expeditee.stats.SessionStats;
 
 //Static methods that provide functions for the objects\
@@ -70 +70 @@
         public static final int TAG_LINE_TEMPLATE = 17;
 
+        public static final int TAG_STAT_TEMPLATE = 18;
+
         public static final int TAG_MIN = 0;
 
-        public static final int TAG_MAX = 17;
+        public static final int TAG_MAX = 18;
 
         /**
@@ -164 +166 @@
                 return isTag(toCheck, GetTag(tag));
         }
-        
+
         public static boolean isTag(Item toCheck, int tag, boolean hasValue) {
                 return isTag(toCheck, GetTag(tag), hasValue);
@@ -187 +189 @@
                 // tags are ase-insensitive
                 return String.CASE_INSENSITIVE_ORDER.compare(txt.getFirstLine().trim(),
-                                tag) == 0 || (hasValue && txt.startsWith(tag + " ", true));
+                                tag) == 0
+                                || (hasValue && txt.startsWith(tag + " ", true));
         }
 
@@ -272 +275 @@
          */
         public static String GetTag(int tag) {
+                // TODO refactor so that this uses a map for INT to tags
                 switch (tag) {
                 case TAG_SORT:
@@ -289 +293 @@
                 case TAG_ANNOTATION_TEMPLATE:
                         return "@annotationtemplate";
+                case TAG_STAT_TEMPLATE:
+                        return "@stattemplate";
                 case TAG_CODE_COMMENT_TEMPLATE:
                         return "@commenttemplate";
@@ -618 +624 @@
                 copy.removeAllConstraints();
 
-                int num = 0;
-
-                // Mike: WHAT IS THIS CODE DOING?!!?
-                for (Line line : origEnd.getLines())
-                        num = Math.min(num, line.getID());
-
-                num--;
-
                 // create a new line
-                Line line = new Line(origEnd, copy, num);
+                Line line = new Line(origEnd, copy, DisplayIO.getCurrentFrame()
+                                .getNextItemID());
                 // copy.setFloating(true);
                 origEnd.setArrowheadLength(0);
@@ -636 +635 @@
                 toReturn.add(line);
                 return toReturn;
+        }
+
+        public static void New() {
+                EnclosedCheck(DisplayIO.getCurrentFrame().getItems());
+        }
+
+        public static void Old() {
+                OldEnclosedCheck(DisplayIO.getCurrentFrame().getItems());
+        }
+
+        /**
+         * Updates the connectedToAnnotation flags for all items
+         */
+        public static void UpdateConnectedToAnnotations(Collection<Item> items) {
+                // get all lineEnds on the Frame
+                Collection<Item> lineEnds = new LinkedHashSet<Item>();
+                for (Item i : items) {
+                        i.setConnectedToAnnotation(false);
+                        if (i.isLineEnd()) {
+                                lineEnds.add(i);
+                        }
+                }
+
+                // if there are no line endpoints on the Frame, then there can't be an
+                // enclosure
+                if (lineEnds.size() == 0)
+                        return;
+
+                // Now find go through line ends and see if any are annotation items
+                while (lineEnds.size() > 0) {
+                        Item item = lineEnds.iterator().next();
+                        // If its an annotation item then set the flag for all its connected
+                        // items
+                        if (item.isAnnotation()) {
+                                Collection<Item> connected = item.getAllConnected();
+                                for (Item i : connected)
+                                        i.setConnectedToAnnotation(true);
+                                lineEnds.removeAll(connected);
+                        }
+                        lineEnds.remove(item);
+                }
         }
 
@@ -646 +686 @@
          * is done dynamically (to account for Dots being moved).
          */
-        public static void EnclosedCheck(List<Item> items) {
+        public static void EnclosedCheck(Collection<Item> items) {
+                // get all lineEnds on the Frame
+                List<Item> lineEnds = new LinkedList<Item>();
+                for (Item i : items) {
+                        if (i.isLineEnd()) {
+                                i.setEnclosedList(null);
+                                // Add line ends joined to 2 other lines
+                                if (i.getLines().size() == 2)
+                                        lineEnds.add(i);
+                        }
+                }
+
+                // if there are no line endpoints on the Frame, then there can't be an
+                // enclosure
+                if (lineEnds.size() == 0)
+                        return;
+
+                // New approach
+                while (lineEnds.size() > 0) {
+                        Item item = lineEnds.get(0);
+                        // Get the lineEnds connected to this item
+                        Collection<Item> connected = item.getAllConnected();
+                        Collection<Item> connectedLineEnds = new LinkedHashSet<Item>();
+                        for (Item itemToCheck : connected) {
+                                if (itemToCheck.isLineEnd())
+                                        connectedLineEnds.add(itemToCheck);
+                        }
+                        // Check that all the line ends are in our lineEnds list
+                        int oldSize = lineEnds.size();
+                        // Remove all the items from our line ends list
+                        lineEnds.removeAll(connectedLineEnds);
+                        int newSize = lineEnds.size();
+                        int connectedSize = connectedLineEnds.size();
+                        // Check if all the connectedItems were in the lineEnds collection
+                        if (oldSize == newSize + connectedSize) {
+                                // Set them to be the enclosed list for each of the items
+                                for (Item enclosedLineEnd : connectedLineEnds) {
+                                        enclosedLineEnd.setEnclosedList(connectedLineEnds);
+                                }
+                        }
+
+                }
+        }
+
+        /**
+         * Checks through all Lines and Dots on the current Frame to detect if any
+         * form an enclosure, which can then be used to manipulate items within the
+         * polygon. If an enclosure is found, then the dots will have their
+         * enclosure value set to true, and a List is created that contains all the
+         * Dots in the order they were processed. Actual calculation of the Polygon
+         * is done dynamically (to account for Dots being moved).
+         */
+        public static void OldEnclosedCheck(Collection<Item> items) {
                 _seen.clear();