Changeset 914

Timestamp:

05/12/14 09:28:44 (10 years ago)

Author:

davidb

Message:

Implicit Boxing

Location:

trunk/src/org/expeditee

Files:

• io/DefaultTreeWriter.java (modified) (2 diffs)
• io/JavaWriter.java (modified) (1 diff)
• io/flowlayout/XGroupItem.java (modified) (6 diffs)
• io/flowlayout/XItem.java (modified) (2 diffs)
• items/Text.java (modified) (1 diff)

trunk/src/org/expeditee/io/DefaultTreeWriter.java

@@ -8 +8 @@
 import org.expeditee.gui.FrameIO;
 import org.expeditee.gui.MessageBay;
+import org.expeditee.io.flowlayout.XGroupItem;
 import org.expeditee.items.Item;
 import org.expeditee.items.Text;
@@ -74 +75 @@
         
         protected void outputTree(Frame toWrite) throws IOException {
-                if (toWrite == null)
+                if (toWrite == null) {
                         return;
-
+                }
+                
+                XGroupItem.doImplicitBoxing = false;
+                
                 _frames.push(new FrameCounter(toWrite.getName(), -1));
 

trunk/src/org/expeditee/io/JavaWriter.java

@@ -67 +67 @@
                 List<Item> y_ordered_items = frame.getItems();
                 
+                for (Item item: y_ordered_items) {
+                        if (item instanceof Text) {
+                                Text text_item = (Text)item;
+                                if (text_item.getText().equalsIgnoreCase("@doImplicitBoxing")) {
+                                        XGroupItem.doImplicitBoxing = true;
+                                }
+                        }
+                }
                 XGroupItem toplevel_xgroup = new XGroupItem(frame,y_ordered_items);
                 

trunk/src/org/expeditee/io/flowlayout/XGroupItem.java

@@ -23 +23 @@
 {
         enum FlowType { in_flow, out_of_flow_original, out_of_flow_faked_position };
+        
+        public static boolean doImplicitBoxing = true;
         
         class MultiArrowHeadComparable implements Comparator<Item>{
@@ -763 +765 @@
         }
         
+        protected int autocropToTop(XItem xitem)
+        {
+                // top-edge over-spill can occur (and is acceptable) when (for example) the given xitem is a raw-text item 
+                // that doesn't neatly fit in an enclosed area (i,e., is poking out the top of an enclosing rectangle)  
+                // => cut down to the top of 'this' xgroupitem
+                
+                int yt = xitem.getBoundingYTop();
+                                
+                
+                yt = cropToTop(yt); // Only changes yt if in an over-spill situation
+                
+                return yt;
+                
+        }
+        
+        protected int autocropToBot(XItem xitem)
+        {
+                
+                // similar to autocropToTop(), bottom-edge over-spill can occur (and is acceptable) with 
+                // a less than precise placed raw-text item 
+                
+                int yb = xitem.getBoundingYBot();
+                
+                yb = cropToBot(yb); // Only changes yb if in an over-spill situation
+                
+                return yb;
+        }
+        
+        protected boolean yExtentIntersection(XGroupItem xgroup_item1, XGroupItem xgroup_item2)
+        {
+                // Computation applied to y-extent of each rectangle
+                
+                // To intersect, either a point in item1 falls inside item2, 
+                // or else item2 is completely within item1 
+                
+        
+                int yt1 = xgroup_item1.getBoundingYTop();
+                int yb1 = xgroup_item1.getBoundingYBot();
+                
+                int yt2 = xgroup_item2.getBoundingYTop();
+                
+                // yt1 insides item2?
+                if (xgroup_item2.containedInYExtent(yt1)) {
+                        return true;
+                }
+                
+                // yb1 inside item2?
+                if (xgroup_item2.containedInYExtent(yb1)) {
+                        return true;
+                }
+                
+                // item2 completely inside item1?
+                //
+                // With the previous testing, this can be determined
+                // by checking only one of the values is inside.
+                // Doesn't matter which => choose yt2
+                
+                if (xgroup_item1.containedInYExtent(yt2)) {
+                        return true;
+                }
+                
+                // Get to here if there is no intersection
+                return false;
+                
+        }
+        protected ArrayList<XGroupItem> calcXGroupYExtentIntersection(XGroupItem xgroup_pivot_item, List<XGroupItem> xgroup_item_list)
+        {
+                ArrayList<XGroupItem> intersect_list = new ArrayList<XGroupItem>();
+                
+                for (XGroupItem xgroup_item: xgroup_item_list) {
+
+                        if (xgroup_item == xgroup_pivot_item) {
+                                // Don't bother working out the intersection with itself!
+                                continue;
+                        }
+
+                        if (yExtentIntersection(xgroup_pivot_item,xgroup_item)) {
+                                intersect_list.add(xgroup_item);
+                        }
+                }
+        
+                return intersect_list;
+        }
+        
+        protected ArrayList<YOverlappingItemsTopEdge> calcYSpanOverlap(XItem xitem)
+        {
+                int yt = autocropToTop(xitem);
+                int yb = autocropToBot(xitem);
+                
+                
+                ArrayList<YOverlappingItemsTopEdge> top_edge_list = new ArrayList<YOverlappingItemsTopEdge>();
+                
+                for (int y=yt; y<=yb; y++) {
+
+                        YOverlappingItemsSpan item_span = getYOverlappingItemsSpan(y);
+
+                        if (item_span != null) {
+
+                                if (item_span instanceof YOverlappingItemsTopEdge) {
+
+                                        YOverlappingItemsTopEdge y_item_span_top_edge = (YOverlappingItemsTopEdge)item_span;
+                                        
+                                        top_edge_list.add(y_item_span_top_edge);
+                                }
+                        }
+
+                }
+                
+                return top_edge_list;
+        }
+        
+        
+        protected boolean multipleYSpanOverlap(XItem xitem)
+        {
+                return calcYSpanOverlap(xitem).size() > 0;
+        }
+        
         public void mapInItem(XItem xitem) 
         {
                 
+                int yt = autocropToTop(xitem);
+                int yb = autocropToBot(xitem);
+                /*
                 int yt = xitem.getBoundingYTop();
                 int yb = xitem.getBoundingYBot();
@@ -775 +897 @@
                 // similarly, bottom-edge over-spill can occur (and is acceptable) with a less than precise placed raw-text item 
                 yb = cropToBot(yb); // Only changes yb if in an over-spill situation
-                        
+                        */
+                
                 // Merge into 'items_span' checking for overlaps (based on xitem's y-span) 
                                 
@@ -871 +994 @@
         }
         
+        private ArrayList<DimensionExtent> calcXGroupXGaps(XGroupItem xgroup_pivot_item, List<XGroupItem> xgroup_item_list) 
+        {
+                // 'xgroup_pivot_item' current not used!!
+                
+                int enclosing_xl = getBoundingXLeft();
+                int enclosing_xr = getBoundingXRight();
+                
+                int enclosing_x_dim = enclosing_xr - enclosing_xl +1;
+                boolean is_x_shadow[] = new boolean[enclosing_x_dim]; // defaults all values to false
+                
+                ArrayList<DimensionExtent> x_gap_list = new ArrayList<DimensionExtent>();
+                
+                for (XGroupItem xgroup_item: xgroup_item_list) {
+                        int xl = xgroup_item.getBoundingXLeft();
+                        int xr = xgroup_item.getBoundingXRight();
+                        
+                        for (int x=xl; x<=xr; x++) {
+                                int x_offset = x - enclosing_xl;
+                                is_x_shadow[x_offset] = true;
+                        }
+                }
+                
+                // New find where the contiguous runs of 'false' are, as they point to the gaps
+                
+                int x = 1;
+                int start_x_gap = enclosing_xl;
+                boolean in_gap = true;
+                
+                while (x < is_x_shadow.length) {
+                        boolean prev_is_shadow = is_x_shadow[x-1];
+                        boolean this_is_shadow = is_x_shadow[x];
+
+                        if (prev_is_shadow && !this_is_shadow) {
+                                // reached end of shadow, record start of a gap
+                                start_x_gap = enclosing_xl + x;
+                                in_gap = true;
+                        }
+                        else if (!prev_is_shadow && this_is_shadow) {
+                                // reached the end of a gap, record it
+                                int end_x_gap = enclosing_xl + x -1;
+                                DimensionExtent de = new DimensionExtent(start_x_gap,end_x_gap);
+                                x_gap_list.add(de);
+                                in_gap = false;
+                        }
+                        x++;
+                }
+                
+                if (in_gap) {
+                        int end_x_gap = enclosing_xl + x -1;
+                        DimensionExtent de = new DimensionExtent(start_x_gap,end_x_gap);
+                        x_gap_list.add(de);
+                }
+                
+                return x_gap_list;
+        }
+
+        protected void boxMultipleXRawItemsInGaps(XGroupItem xgroup_pivot_item, ArrayList<DimensionExtent> x_text_gap_list) 
+        {
+                ArrayList<YOverlappingItemsTopEdge> y_span_overlap = calcYSpanOverlap(xgroup_pivot_item);
+                
+                // work out where continuous runs of raw-text items intersect with the gaps occurring between boxed items
+                
+                // foreach x-gap, 
+                //    foreach y-span's list of x-sorted objects, 
+                //      => see how many raw-text items fit into it
+                
+                
+                ArrayList<ArrayList<XRawItem>> implicit_box_list = new ArrayList<ArrayList<XRawItem>>();
+                
+                for (DimensionExtent de_gap: x_text_gap_list) {
+                        
+                        int deg_xl = de_gap.min;
+                        int deg_xr = de_gap.max;
+                        
+                        ArrayList<XRawItem> grouped_raw_text_list = new ArrayList<XRawItem>();
+                        
+                        int y_span_line_count = 0;
+                        
+                        for (YOverlappingItemsTopEdge y_top_edge: y_span_overlap) {
+                                
+                                List<XItem> x_item_list = y_top_edge.x_items.getXItemList();
+
+                                boolean used_x_raw_text = false;
+                                
+                                for (XItem x_item: x_item_list) {
+                                
+                                        if (x_item instanceof XRawItem) {
+                                                XRawItem x_raw_item = (XRawItem)x_item;
+                                                
+                                                int xri_xl = x_raw_item.getBoundingXLeft();
+                                                int xri_xr = x_raw_item.getBoundingXRight();
+                                                
+                                                if ((xri_xl>=deg_xl) && (xri_xr<=deg_xr)) {
+                                                        grouped_raw_text_list.add(x_raw_item);
+                                                        used_x_raw_text = true;
+                                                }
+                                        }
+                                }
+                                
+                                if (used_x_raw_text) {
+                                        y_span_line_count++;
+                                }
+                        }
+                        
+                        // Only interested in implicitly boxing if the formed group is used over 2 or more y-span lines
+                        if (y_span_line_count>=2) {
+                                implicit_box_list.add(grouped_raw_text_list);
+                        }
+                }
+                
+                //System.err.println("*** Number of implicit groups found: " + implicit_box_list.size());
+                
+                for (ArrayList<XRawItem> implicit_x_item_list : implicit_box_list) {
+                        
+                        for (YOverlappingItemsTopEdge y_top_edge: y_span_overlap) {
+                                
+                                List<XItem> yspan_x_item_list = y_top_edge.x_items.getXItemList();
+                                
+                                // Remove all the XRawItems from the current y-span
+                                yspan_x_item_list.removeAll(implicit_x_item_list);
+                        
+                        }
+                        
+                        // Create a list of original Text items
+                        // (OK that they are not y-ordered)
+                        ArrayList<Item> implicit_item_list= new ArrayList<Item>();
+                        for (XRawItem x_raw_item: implicit_x_item_list) {
+                                Item item = (Text) x_raw_item.item;
+                                implicit_item_list.add(item);
+                        }
+
+                        // Now insert them as their own boxed up items
+                        XGroupItem implicit_xgroup = new XGroupItem(frame,implicit_item_list);
+                        this.mapInItem(implicit_xgroup);
+                }
+                
+        }
+        
+        protected void implicitBoxing(XGroupItem xgroup_pivot_item,List<XGroupItem> xgroup_item_list) {
+                
+                // Implicit boxing is needed if there are two or more raw-text items 
+                // that overlap in y-span-map of the given xgroup_item
+                
+                // First establish if there is any kind of multiple overlap
+                if (multipleYSpanOverlap(xgroup_pivot_item)) {
+                        
+                        // Overlap could be with other boxed items, so need to investigate further
+                        
+                        // Do this by working out if there are any raw-text items lurking between the pivot xgroup_item 
+                        // and the list of other xgroup_items 
+                        
+                        // Step 1: Get list intersection (y-dim) of this group item, with any 
+                        //         other group items in xgroup_item_list
+                        ArrayList<XGroupItem> y_overlapping_xgroup_item_list = calcXGroupYExtentIntersection(xgroup_pivot_item,xgroup_item_list);
+                        
+                        // Step 2: Work out where the gaps are between the y-overlapping boxes in the x-dimension
+                        ArrayList<DimensionExtent> x_text_gap_list = calcXGroupXGaps(xgroup_pivot_item,y_overlapping_xgroup_item_list);
+                        
+                        // Step 3: Remove any sequences of raw-text items that fall in the gaps from YSpan, box them up, and reinsert
+                        boxMultipleXRawItemsInGaps(xgroup_pivot_item,x_text_gap_list);
+                        
+                }
+        }
+        
+        
+
         public void mapInXGroupItemsRecursive(List<XGroupItem> xgroup_item_list)
         {
@@ -877 +1166 @@
                 for (XGroupItem xgroup_item: xgroup_item_list) {
                         if (!xgroup_item.isOriginalOutOfFlowItem()) {
+                                
+                                // See if any implicit boxing of raw-text items is needed
+                                if (doImplicitBoxing) {
+                                        implicitBoxing(xgroup_item,xgroup_item_list);
+                                }
                                 mapInItem(xgroup_item); // Map in this x-group-item
                         }
@@ -892 +1186 @@
         }
         
+        
+
         public ArrayList<Item> getYXOverlappingItemList(boolean separateGroups)
         {

trunk/src/org/expeditee/io/flowlayout/XItem.java

@@ -47 +47 @@
         }
         
+        public int getBoundingXRight()
+        {
+                return bounding_rect.x + bounding_rect.width -1;
+        }
+        
         public int getBoundingWidth()
         {
@@ -76 +81 @@
                 return bounding_rect.contains(pt);
         }
+        
+        public boolean containedInXExtent(int x) 
+        {
+                int xl = getBoundingXLeft();
+                int xr = getBoundingXRight();
+                
+                return (x>= xl) && (x<=xr);
+        }
+        
+        
+        public boolean containedInYExtent(int y) 
+        {
+                int yt = getBoundingYTop();
+                int yb = getBoundingYBot();
+                
+                return (y>= yt) && (y<=yb);
+        }
+        
+        
 }

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

@@ -1875 +1875 @@
                                 int ldx = 1+getX()+getJustOffset(layout); // Layout draw x
                                 
-                                boolean debug = true;
+                                boolean debug = false;
                                 if (debug) {
                                         g.setColor(new Color(c.getRed(),c.getGreen(),c.getBlue(),40));