Changeset 866

Timestamp:

02/08/14 15:08:51 (10 years ago)

Author:

davidb

Message:

Code to allow interactive widgets to have their respective corners anchored both left and right, top and bottom, so will naturally resize when windows size changed

Location:

trunk/src/org/expeditee/items/widgets

Files:

• InteractiveWidget.java (modified) (19 diffs)
• WidgetCorner.java (modified) (5 diffs)

trunk/src/org/expeditee/items/widgets/InteractiveWidget.java

@@ -13 +13 @@
 import java.awt.event.KeyListener;
 import java.awt.event.MouseEvent;
+import java.io.PrintWriter;
+import java.io.StringWriter;
 import java.lang.reflect.Constructor;
 import java.util.ArrayList;
@@ -20 +22 @@
 import java.util.LinkedList;
 import java.util.List;
+import java.util.StringTokenizer;
 
 import javax.swing.JComponent;
 import javax.swing.SwingUtilities;
 
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.GnuParser;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.OptionBuilder;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.ParseException;
 import org.expeditee.actions.Actions;
 import org.expeditee.gui.Browser;
@@ -72 +83 @@
         protected Text _textRepresentation;
 
+        protected Float _anchorLeft;
+        protected Float _anchorRight;
+        protected Float _anchorTop;
+        protected Float _anchorBottom;
+        
         protected final static Color FREESPACE_BACKCOLOR = new Color(100, 100, 100);
 
@@ -135 +151 @@
 
                 String text = source.getText();
-                if (text == null)
+                if (text == null) {
                         throw new IllegalArgumentException("source does not have any text");
+                }
 
                 text = text.trim();
 
-                // Check starts with the widget tag and seporator
+                // Check starts with the widget tag and separator
                 if (!text.startsWith(TAG + ":"))
-                        throw new IllegalArgumentException("Source text must begin with \""
-                                        + TAG + ":\"");
-
+                        throw new IllegalArgumentException("Source text must begin with \"" + TAG + ":\"");
+
+                // skip over the '@iw:' preamble
                 text = text.substring(TAG.length() + 1).trim();
 
                 int index = 0;
                 if (text.length() > 0) {
-                        index = text.indexOf(':'); // used for
-                        // signifying start
-                        // of arguments
-                }
-
-                if (index == 0)
-                        throw new IllegalArgumentException("Source text must begin with \""
-                                        + TAG + "\"");
-
-                String[] tokens = (index == -1) ? text.split("\\s+") : text.substring(
-                                0, index).split(" ");
-
+                    // Having removed @iw:, then next ':' is used for signifying start of arguments
+                    index = text.indexOf(':'); 
+                }
+
+                if (index == 0) {
+                    throw new IllegalArgumentException("Source text must begin with \"" + TAG + "\"");
+                }
+
+                //
+                // Step 1: 
+                //   For an X-rayable text item in the form:
+                //     @iw: <class name> [options] width height : <rest...>
+                //
+                //   Parse the 'core' part of the X-rayable text item
+                //   i.e, the text between the first ':' and the second ':'
+                //  
+                //
+                
+                String tokens_str = (index == -1) ? text : text.substring(0, index);
+
+                String[] tokens = parseArgsApache(tokens_str);
+
+                // make anything starting with a '-' lowercase
+                for (int i=0; i<tokens.length; i++) {
+                        if (tokens[i].startsWith("-")) {
+                                tokens[i] = tokens[i].toLowerCase();
+                        }
+                }
+                
+                // create the command line parser
+                CommandLineParser parser = new GnuParser();
+
+                // create the Options
+                Options options = new Options();
+                options.addOption( "al", "anchorleft",   true, "Anchor the vertical left-hand edge of the interactive widget to the value provided " );
+                options.addOption( "ar", "anchorright",  true, "Anchor the vertical right-hand edge of the interactive widget to the value provided " );
+                options.addOption( "at", "anchortop",    true, "Anchor the vertical top edge of the interactive widget to the value provided " );
+                options.addOption( "ab", "anchorbottom", true, "Anchor the vertical bottom edge of the interactive widget to the value provided " );
+                
+                /*
+                 * Alternative way to do the above, but with more control over how the values are set up and can be used
+                 * 
+                @SuppressWarnings("static-access")
+                Option anchor_left_opt = OptionBuilder.withLongOpt( "anchorleft" )
+                                .withDescription( "use <x-pos> as left anchor for the vertical lefthand edge of the interactive widget" )
+                                .hasArg()
+                                .withArgName("<x-pos>")
+                                .create("al");
+         
+                @SuppressWarnings("static-access")
+                Option anchor_right_opt = OptionBuilder.withLongOpt( "anchorright" )
+                                .withDescription( "use <x-pos> as right anchor for the vertical righthand edge of the interactive widget" )
+                                .hasArg()
+                                .withArgName("<x-pos>")
+                                .create("ar");
+                
+                
+                @SuppressWarnings("static-access")
+                Option anchor_top_opt = OptionBuilder.withLongOpt( "anchortop" )
+                                .withDescription( "use <y-pos> as top anchor for the horizontal top end of the interactive widget" )
+                                .hasArg()
+                                .withArgName("<x-pos>")
+                                .create("at");
+         
+                @SuppressWarnings("static-access")
+                Option anchor_bottom_opt = OptionBuilder.withLongOpt( "anchorbottom" )
+                                .withDescription( "use <y-pos> as bottom anchor for the horizontal bottom edge of the interactive widget" )
+                                .hasArg()
+                                .withArgName("<x-pos>")
+                                .create("ab");
+                
+                options.addOption(anchor_left_opt);
+                options.addOption(anchor_right_opt);
+                options.addOption(anchor_top_opt);
+                options.addOption(anchor_bottom_opt);
+                */
+
+                CommandLine core_line;
+                try {
+                    // parse the command line arguments
+                    core_line = parser.parse( options, tokens );
+                    
+                    // Update tokens to be version with the options removed
+                    tokens = core_line.getArgs();
+                    
+                }
+                catch( ParseException exp ) {
+                    System.err.println( "Unexpected exception:" + exp.getMessage() );
+                    core_line = null;
+                    
+                }
+                
+                HelpFormatter formatter = new HelpFormatter();
+                StringWriter usage_str_writer = new StringWriter();
+            PrintWriter printWriter = new PrintWriter(usage_str_writer);
+            
+            String widget_name = tokens[0];
+            final String widget_prefix = "org.expeditee.items.widgets";
+            if (widget_name.startsWith(widget_prefix)) {
+                widget_name = widget_name.substring(widget_prefix.length());
+            }
+            
+                formatter.printHelp(printWriter, 80, TAG + ":" + widget_name + " [options] width height", null, options, 4, 0, null);
+                System.out.println(usage_str_writer.toString());
+                
                 float width = -1, height = -1;
 
-                if (tokens.length < 1)
-                        throw new IllegalArgumentException(
-                                        "Missing widget class name in source text");
+                if (tokens.length < 1) {
+                        throw new IllegalArgumentException("Missing widget class name in source text");
+                }
 
                 try {
@@ -200 +310 @@
                                         + " does not exist or is not an InteractiveWidget");
 
+                
+                //
+                // Step 2: 
+                //   For an X-rayable text item in the form:
+                //     @iw: <class name> [options] width height : <rest...>
+                //
+                //   Parse the <rest ...> part
+                
                 // Extract out the parameters - if any
                 String[] args = null;
                 if (index > 0) { // index of the first ":"
-                        args = (text.length() == (index + 1)) ? null : parseArgs(text
-                                        .substring(index + 1));
+                        if (text.length()>(index+1)) {
+                                String args_str = text.substring(index + 1);
+                                
+                                 args = parseArgsApache(args_str);
+                
+                        }       
                 }
 
@@ -222 +344 @@
                 }
 
-                // Use default dimensions if not provided (or provided as negitive
+                // Step 3: 
+                //    Set up the size and position of the widget
+
+                // Use default dimensions if not provided (or provided as negative
                 // values)
-                if (width <= 0)
+                if (width <= 0) {
                         width = inst.getWidth();
-                if (height <= 0)
+                }
+                if (height <= 0) {
                         height = inst.getHeight();
+                }
 
                 inst.setSize(width, height);
-
+                
+                // Apply any anchor values supplied in the core part of the @iw item
+                Float anchor_left   = null;
+                Float anchor_right  = null;
+                Float anchor_top    = null;
+                Float anchor_bottom = null;
+                
+            if(core_line.hasOption( "anchorleft" ) ) {
+                String al_str = core_line.getOptionValue( "anchorleft" );
+                
+                anchor_left = Float.parseFloat(al_str);
+            }
+            
+            if(core_line.hasOption( "anchorright" ) ) {
+                String ar_str = core_line.getOptionValue( "anchorright" );
+                
+                anchor_right = Float.parseFloat(ar_str);
+            }
+            
+            if(core_line.hasOption( "anchortop" ) ) {
+                String at_str = core_line.getOptionValue( "anchortop" );
+                
+                anchor_top = Float.parseFloat(at_str);
+            }
+            
+            if(core_line.hasOption( "anchorbottom" ) ) {
+                String ab_str = core_line.getOptionValue( "anchorbottom" );
+                
+                anchor_bottom = Float.parseFloat(ab_str);
+            }
+            
+            inst.setAnchorCorners(anchor_left,anchor_right,anchor_top,anchor_bottom);
+            
+        
+                
                 return inst;
         }
@@ -319 +480 @@
 
                         } else if (c == '\"') {
-                                // If double qouted
+                                // If double quoted
                                 if (args.length() >= (i + 2) && args.charAt(i + 1) == '\"') {
 
@@ -376 +537 @@
                 return sb.length() > 0 ? sb.toString() : null;
         }
+
+
+
+
+    /**
+     * Similar to parseArgs() above.  
+     * Code based on routine used in Apache Ant:
+     *   org.apache.tools.ant.types.Commandline::translateCommandline()
+     * @param toProcess the command line to process.
+     * @return the command line broken into strings.
+     * An empty or null toProcess parameter results in a zero sized array.
+     */
+    public static String[] parseArgsApache(String toProcess) {
+        if (toProcess == null || toProcess.length() == 0) {
+            //no command? no string
+            return new String[0];
+        }
+        // parse with a simple finite state machine
+
+        final int normal = 0;
+        final int inQuote = 1;
+        final int inDoubleQuote = 2;
+        int state = normal;
+        final StringTokenizer tok = new StringTokenizer(toProcess, "\"\' ", true);
+        final ArrayList<String> result = new ArrayList<String>();
+        final StringBuilder current = new StringBuilder();
+        boolean lastTokenHasBeenQuoted = false;
+
+        while (tok.hasMoreTokens()) {
+            String nextTok = tok.nextToken();
+            switch (state) {
+            case inQuote:
+                if ("\'".equals(nextTok)) {
+                    lastTokenHasBeenQuoted = true;
+                    state = normal;
+                } else {
+                    current.append(nextTok);
+                }
+                break;
+            case inDoubleQuote:
+                if ("\"".equals(nextTok)) {
+                    lastTokenHasBeenQuoted = true;
+                    state = normal;
+                } else {
+                    current.append(nextTok);
+                }
+                break;
+            default:
+                if ("\'".equals(nextTok)) {
+                    state = inQuote;
+                } else if ("\"".equals(nextTok)) {
+                    state = inDoubleQuote;
+                } else if (" ".equals(nextTok)) {
+                    if (lastTokenHasBeenQuoted || current.length() != 0) {
+                        result.add(current.toString());
+                        current.setLength(0);
+                    }
+                } else {
+                    current.append(nextTok);
+                }
+                lastTokenHasBeenQuoted = false;
+                break;
+            }
+        }
+        if (lastTokenHasBeenQuoted || current.length() != 0) {
+            result.add(current.toString());
+        }
+        if (state == inQuote || state == inDoubleQuote) {
+            System.err.println("Error: Unbalanced quotes -- failed to parse '" + toProcess + "'");
+            return null;
+        }
+
+        return result.toArray(new String[result.size()]);
+    }
+
+
+
 
         /**
@@ -456 +694 @@
                 _textRepresentation = source;
 
-                setSizeRestrictions(minWidth, maxWidth, minHeight, maxHeight); // throws
-                // IllegalArgumentException's
+                setSizeRestrictions(minWidth, maxWidth, minHeight, maxHeight); // throws IllegalArgumentException's
 
                 int x = source.getX();
@@ -608 +845 @@
         /**
          * @return The current representation for this widget. The representation
-         *         stores link infomation, data etc... It is used for saving and
+         *         stores link information, data etc... It is used for saving and
          *         loading of the widget. Never null.
          * 
@@ -617 +854 @@
 
         /**
-         * @return The expeditee anotation string.
+         * @return The Expeditee annotation string.
          */
         protected String getAnnotationString() {
@@ -628 +865 @@
                 sb.append(getClass().getName());
 
-                // Append size information if needed (not an attibute of text items)
+                if (_anchorLeft != null) {
+                    sb.append(" -anchorLeft " + Math.round(_anchorLeft));
+                }
+                if (_anchorRight != null) {
+                    sb.append(" -anchorRight " + Math.round(_anchorRight));
+                }
+
+                if (_anchorTop != null) {
+                    sb.append(" -anchorTop " + Math.round(_anchorTop));
+                }
+
+                if (_anchorBottom != null) {
+                    sb.append(" -anchorBottom " + Math.round(_anchorBottom));
+                }
+
+                // Append size information if needed (not an attribute of text items)
                 if (!isFixedSize()) {
                         sb.append(' ');
@@ -647 +899 @@
 
         /**
-         * Sets both the new size as well as the new min/max widdet/height
-         * restricitons.
+         * Sets both the new size as well as the new min/max widget/height
+         * restrictions.
          * 
          * @param minWidth
@@ -700 +952 @@
         public void setSize(float width, float height) {
 
-                // Clamp
-                if (width < _minWidth && _minWidth >= 0)
+                // If 'width' and 'height' exceed the min/max values for width/height
+                // => clamp to the relevant min/max value 
+                if (width < _minWidth && _minWidth >= 0) {
                         width = _minWidth;
-                else if (width > _maxWidth && _maxWidth >= 0)
+                }
+                else if (width > _maxWidth && _maxWidth >= 0) {
                         width = _maxWidth;
-
-                if (height < _minHeight && _minHeight >= 0)
+                }
+                
+                if (height < _minHeight && _minHeight >= 0) {
                         height = _minHeight;
-                else if (height > _maxHeight && _maxHeight >= 0)
+                }
+                else if (height > _maxHeight && _maxHeight >= 0) {
                         height = _maxHeight;
-
+                }
+                
+                // Remember current isFloating() values
                 boolean vfloating[] = new boolean[] { _d1.isFloating(),
                                 _d2.isFloating(), _d3.isFloating(), _d4.isFloating() };
@@ -719 +977 @@
                 _d4.setFloating(true);
 
-                float x = _d1.getX() + width;
-                float y = _d1.getY() + height;
-
-                _d2.setX(x);
-                _d3.setX(x);
-                _d3.setY(y);
-                _d4.setY(y);
-
+                float xr = _d1.getX() + width;
+                float yb = _d1.getY() + height;
+
+                _d2.setX(xr);
+                _d3.setX(xr);
+                _d3.setY(yb);
+                _d4.setY(yb);
+
+                // Restore isFloating() values
                 _d1.setFloating(vfloating[0]);
                 _d2.setFloating(vfloating[1]);
@@ -735 +994 @@
         }
 
+    public void setAnchorCorners(Float left, Float right, Float top, Float bottom)
+    {
+        setAnchorLeft(left);
+        setAnchorRight(right);
+        setAnchorTop(top);
+        setAnchorBottom(bottom);
+    }
+    
+
         public void setPosition(int x, int y) {
                 if (x == getX() && y == getY())
                         return;
 
+                // Remember current isFloating() values
                 boolean vfloating[] = new boolean[] { _d1.isFloating(),
                                 _d2.isFloating(), _d3.isFloating(), _d4.isFloating() };
@@ -757 +1026 @@
                 _d4.setPosition(x, y + height);
 
+                // Restore isFloating() values
                 _d1.setFloating(vfloating[0]);
                 _d2.setFloating(vfloating[1]);
@@ -771 +1041 @@
 
         /**
-         * to be called from corners only
+         * Updates position of given WidgetCorner to the given (x,y), 
+         *   and updates related values (connected corners, width and height)
          * 
          * @param src
@@ -1719 +1990 @@
         }
 
+        public void setAnchorLeft(Float anchor) {
+                _anchorLeft = anchor;
+                // Anchor left-edge corners (dots) as well
+                _d1.setAnchorCornerX(anchor,null); 
+                _d4.setAnchorCornerX(anchor,null); 
+
+                if (anchor != null) {
+                    setPositions(_d1, anchor, _d1.getY());
+                    onResized();
+                }
+                
+                // Move X-rayable items as well
+                getSource().setAnchorLeft(anchor);
+        }
+
+        public void setAnchorRight(Float anchor) {
+                _anchorRight = anchor;
+                // Anchor right-edge corners (dots) as well
+                _d2.setAnchorCornerX(null,anchor); // right
+                _d3.setAnchorCornerX(null,anchor); // right
+
+                if (anchor != null) {
+                        setPositions(_d2, FrameGraphics.getMaxFrameSize().width - anchor, _d2.getY());
+                        onResized();
+                }
+                
+                if (_anchorLeft == null) {
+                        // Prefer having the X-rayable item at anchorLeft position (if defined) over moving to anchorRight
+                        getSource().setAnchorRight(anchor);
+                }
+        }
+        
         public void setAnchorTop(Float anchor) {
-                setPosition(getX(),Math.round(anchor));
+                _anchorTop = anchor;
+                // Anchor top-edge corners (dots) as well
+                _d1.setAnchorCornerY(anchor,null);
+                _d2.setAnchorCornerY(anchor,null); 
+                
+                if (anchor != null) {
+                    setPositions(_d2, _d2.getX(), anchor);
+                    onResized();
+                }
+        
+                // Move X-rayable items as well
                 getSource().setAnchorTop(anchor);
         }
 
         public void setAnchorBottom(Float anchor) {
-                setPosition(getX(),
-                            Math.round(FrameGraphics.getMaxFrameSize().height - anchor - getHeight()));
-                getSource().setAnchorBottom(anchor);
-        }
-
-        public void setAnchorLeft(Float anchor) {
-                setPosition(Math.round(anchor),
-                            getY());
-                getSource().setAnchorLeft(anchor);
-        }
-
-        public void setAnchorRight(Float anchor) {
-                setPosition(Math.round(FrameGraphics.getMaxFrameSize().width - anchor - getWidth()),
-                            getY());
-                getSource().setAnchorRight(anchor);
-        }
+                _anchorBottom = anchor;
+                // Anchor bottom-edge corners (dots) as well
+                _d3.setAnchorCornerY(null,anchor); 
+                _d4.setAnchorCornerY(null,anchor); 
+                
+                if (anchor != null) {
+                    setPositions(_d3, _d3.getX(), FrameGraphics.getMaxFrameSize().height  - anchor);
+                    onResized();
+                }
+                
+                if (_anchorTop == null) {
+                    // Prefer having the X-rayable item at anchorTop position (if defined) over moving to anchorBottom
+                    getSource().setAnchorBottom(anchor);
+                }
+        }
+
 
         public boolean isAnchored() {
-                return getSource().isAnchored();
+                        return (isAnchoredX()) || (isAnchoredY());
+                        
+                //return getSource().isAnchored();
         }
 
         public boolean isAnchoredX() {
-                return getSource().isAnchoredX();
+                return (_anchorLeft != null) || (_anchorRight != null);
+                //return getSource().isAnchoredX();
         }
 
         public boolean isAnchoredY() {
-                return getSource().isAnchoredY();
+                return (_anchorTop != null) || (_anchorBottom != null);
+                //return getSource().isAnchoredY();
         }
         

trunk/src/org/expeditee/items/widgets/WidgetCorner.java

@@ -36 +36 @@
                                 super.setPosition(x, y);
                         }
-                } else
+                } 
+                else {
                         super.setPosition(x, y);
+                }
                 invalidateFill();
         }
@@ -48 +50 @@
                                 super.setXY(x, y);
                         }
-                } else
+                } 
+                else {
                         super.setXY(x, y);
+                }
                 invalidateFill();
         }
@@ -164 +168 @@
         }
 
+        public void setAnchorCornerX(Float anchorLeft, Float anchorRight) {
+                _anchorLeft = anchorLeft;
+                _anchorRight = anchorRight;
+        }
+        
+        public void setAnchorCornerY(Float anchorTop, Float anchorBottom) {
+                _anchorTop = anchorTop;
+                _anchorBottom= anchorBottom;
+        }
+        
+        @Override
+        public void setAnchorLeft(Float anchor) {
+                _widgetSource.setAnchorLeft(anchor);
+                _anchorLeft = anchor;
+                _anchorRight = null;
+        }
+
+        @Override
+        public void setAnchorRight(Float anchor) {
+                _widgetSource.setAnchorRight(anchor);
+                _anchorLeft = null;
+                _anchorRight = anchor;
+        }
+        
         @Override
         public void setAnchorTop(Float anchor) {
                 _widgetSource.setAnchorTop(anchor);
+                _anchorTop = anchor;
+                _anchorBottom = null;
         }
 
@@ -172 +202 @@
         public void setAnchorBottom(Float anchor) {
                 _widgetSource.setAnchorBottom(anchor);
-        }
-
-        @Override
-        public void setAnchorLeft(Float anchor) {
-                _widgetSource.setAnchorLeft(anchor);
-        }
-
-        @Override
-        public void setAnchorRight(Float anchor) {
-                _widgetSource.setAnchorRight(anchor);
-        }
-
+                _anchorTop = null;
+                _anchorBottom = anchor;
+        }
+
+        /*
         @Override
         public Float getAnchorTop() {
@@ -203 +226 @@
                 return _widgetSource.getSource().getAnchorRight();
         }
-
+*/
+        
         @Override
         public void setLink(String link) {