/*     Copyright: Sun Microsystems 1997.  All rights reserved.    Author: Patrick Chan (www.xeo.com)   7/19/96    Version: 1.1	Modified by Phil Bartholo to create a horizontal nav	bar.*/    import java.applet.*;import java.awt.*;import java.util.*;import java.net.*;public class horizMenu extends Applet {    // The background image.  This had better not be null.    Image image;    // These two fields are used to do double-buffering.    // The dimensions of bbuf is exactly the dimensions of the applet.    Image bbuf;    Graphics bbufG;    // This field is set to true only when the background image has    // completely loaded.    boolean imageDone;    /* Menu data */    Rectangle[] hitArea;    Rectangle[] srcRect;    Point[] dstPt;    boolean[] down;    String[] url;    /* Submenu data */    String[][] itemUrl;    String[][] item;	/* Margins to draw menu items */	int rightLimit;	int bottomLimit;    // If >= 0, this fields holds the index of the current menu.    // If -1, no menu is current.    int curMenu;    // If >= 0, this fields holds the index of the current menu item.    // If -1, no menu item is current.    int curMenuItem = -1;    // This is an array of rectangles - one rectangle for each menu item.      // Each rectangle specifies the    // location (relative to the left-corner of the applet) of a menu item.    //    // menuItemRect is null when curMenu is -1.    // It becomes non-null when curMenu >= 0.    //    // Note: it would have been better programming to define classes for     // the menu and menu items.  However, I decided for this little applet    // to keep the number of class files to a minimum to minimize the download    // time.      Rectangle[] menuItemRect;    // This is the color to paint "behind" the image.    Color bgColor;    // [0] is the text color of a menu item; [1] is the text color of a highlighted    // menu item.    Color fgMenuColor[] = new Color[2];    // This is the background of a menu item; [1] is the background color of a    // highlighted menu item.    Color bgMenuColor[] = new Color[2];    // marginH is the number of pixels on the left and right edges of the menu.    // marginV is the number of pixels on the top and bottom edges of the menu.    int marginH, marginV;    // This is the font used to display the menu item labels.    Font f;    // This is the font metrics of 'f'.      FontMetrics fm;    public void init() {	int[] ints;        // Grab applet parameters.        image = getImage(getCodeBase(), getParameter("image"));        marginH = Integer.parseInt(getParameter("marginh"));        marginV = Integer.parseInt(getParameter("marginv"));        // Get color parameters.	ints = parseInt(getParameter("bg-color"), " ");        bgColor = new Color(ints[0], ints[1], ints[2]);	ints = parseInt(getParameter("fg-menu-color"), " ");        fgMenuColor[0] = new Color(ints[0], ints[1], ints[2]);	ints = parseInt(getParameter("fg-hi-menu-color"), " ");        fgMenuColor[1] = new Color(ints[0], ints[1], ints[2]);	ints = parseInt(getParameter("bg-menu-color"), " ");        bgMenuColor[0] = new Color(ints[0], ints[1], ints[2]);	ints = parseInt(getParameter("bg-hi-menu-color"), " ");        bgMenuColor[1] = new Color(ints[0], ints[1], ints[2]);        // Create back buffer for double-buffering.        bbuf = createImage(size().width, size().height);        bbufG = bbuf.getGraphics();        // Determine the font from the font-height.        int fh = Integer.parseInt(getParameter("font-height"));        int i = fh;        while (i > 10) {            f = new Font(getParameter("font"), Font.PLAIN, i);            fm = getFontMetrics(f);            if (fm.getHeight() <= fh) {                break;            }            i--;        }         // Get the menu parameters.        for (i=0; ; i++) {            if (getParameter("menu"+i) == null) {                hitArea = new Rectangle[i];                srcRect = new Rectangle[i];                dstPt = new Point[i];                url = new String[i];		down = new boolean[i];                itemUrl = new String[i][];		item = new String[i][];                break;            }        }        for (i=0; i<hitArea.length; i++) {	    String[] fields = parse(getParameter("menu"+i), getParameter("separator"));                        // Get the hit area.            ints = parseInt(fields[0], " ");            hitArea[i] = new Rectangle(ints[0], ints[1], ints[2], ints[3]);			rightLimit = ints[0]+ints[2];			bottomLimit = ints[1]+ints[3];            // Get the source image.            ints = parseInt(fields[1], " ");            srcRect[i] = new Rectangle(ints[0], ints[1], ints[2], ints[3]);            // Get the destination point.            ints = parseInt(fields[2], " ");            dstPt[i] = new Point(ints[0], ints[1]);	    down[i] = fields[3].equals("d");	    url[i] = fields[4];            item[i] = new String[(fields.length-5)/2];            itemUrl[i] = new String[(fields.length-5)/2];            for (int j=0; j<item [i].length; j++) {                item[i][j] = fields[j*2+5];                itemUrl[i][j] = fields[j*2+6];            }        }    }    // s is a string containing 'sep' separators.  This method    // breaks up the string at the separators and returns the resulting    // strings in an array.  The result may have zero length but is never null.    String[] parse(String s, String sep) {	StringTokenizer st = new StringTokenizer(s, sep);        String result[] = new String[st.countTokens()];	for (int i=0; i<result.length; i++) {            result[i] = st.nextToken();	}        return result;    }    // This method is similar to parse() except that the strings are     // assumed to be decimal integers.  This method coverts these integer    // strings into integers and returns them in an array.    // The result may have zero length but is never null.    int[] parseInt(String s, String sep) {	StringTokenizer st = new StringTokenizer(s, sep);        int[] result = new int[st.countTokens()];	for (int i=0; i<result.length; i++) {            result[i] = Integer.parseInt(st.nextToken());	}        return result;    }    public void paint(Graphics g) {        imageDone = false;        update(g);    }    public void update(Graphics g) {        Graphics g2;        if (!imageDone) {        			g.setColor(bgColor);			g.fillRect( 0,0, rightLimit, (bottomLimit * 4 ) );            imageDone = g.drawImage(image, 0, 0, this);            return;        }                bbufG.setColor(bgColor);		bbufG.fillRect(0, 0, size().width, size().height);        bbufG.drawImage(image, 0, 0, this);                if (curMenu >= 0) {	    	g2 = bbuf.getGraphics();	    	for (int i=0; i<menuItemRect.length; i++) {				drawMenuItem(g2, i);	    	}	    	g2.dispose();            			g2 = bbuf.getGraphics();            // Paint the overlay image            g2.clipRect(dstPt[curMenu].x, dstPt[curMenu].y,                srcRect[curMenu].width, srcRect[curMenu].height);            g2.drawImage(image, dstPt[curMenu].x-srcRect[curMenu].x,                dstPt[curMenu].y-srcRect[curMenu].y, this);            g2.dispose();        }        g.drawImage(bbuf, 0, 0, this);    }    void drawMenuItem(Graphics g, int i) {        int x, y, w, height, secondRowNum, horizOffset, rightMargin; 		int height_adjust = 0;        		// break the menu item label into lines.        String[] line = parse(item[curMenu][i], getParameter("newline"));		//set horizontal offset		horizOffset = dstPt[curMenu].x;		rightMargin = horizOffset + ( menuItemRect[i].width * menuItemRect.length ); 		//try right justifying first if menu is too big		if ( rightMargin > rightLimit )		{			horizOffset = rightLimit - ( menuItemRect.length * menuItemRect[i].width ) -1;			rightMargin = horizOffset + ( menuItemRect[i].width * menuItemRect.length ); 		}		//if it's still too big, just start it at the beginning		if ( horizOffset < 0 )		{			horizOffset = 0;		}		menuItemRect[i].x = horizOffset + (menuItemRect[i].width * i);		menuItemRect[i].y = bottomLimit;				if ( (menuItemRect[i].x + menuItemRect[i].width) > rightLimit )		{			 secondRowNum = ( ( menuItemRect[i].x + menuItemRect[i].width ) % rightLimit );			secondRowNum = ( secondRowNum % rightLimit );			secondRowNum -= ( secondRowNum % menuItemRect[i].width );			secondRowNum = (int) ( secondRowNum / menuItemRect[i].width );			height_adjust = menuItemRect[i].height;				menuItemRect[i].x = secondRowNum * menuItemRect[i].width;			menuItemRect[i].y += menuItemRect[i].height;		}        int hi = 0;        if (i == curMenuItem) {	    	hi = 1;	    	getAppletContext().showStatus(itemUrl[curMenu][i]);        }		g.setColor(bgMenuColor[hi]);		g.fillRect(menuItemRect[i].x, menuItemRect[i].y,	    menuItemRect[i].width, menuItemRect[i].height);        // set color for text and box		g.setColor(fgMenuColor[hi]);        // draw box around menu item.		g.drawRect(menuItemRect[i].x, menuItemRect[i].y,	    menuItemRect[i].width, menuItemRect[i].height);        // draw label        g.setFont(f);	    x = menuItemRect[i].x + 2;		y = 26 + height_adjust;		int baseWidth = 2;        for (i=0; i<line.length; i++) 		{			Integer inum = new Integer(i);			String ivalue = inum.toString();            g.drawString( line[i], x, y + ( i*24 ) );			baseWidth += x;        }    }    public boolean mouseExit(Event evt, int x, int y) {        curMenuItem = curMenu = -1;		repaint();        return true;    }    public boolean mouseEnter(Event evt, int x, int y) {		curMenuItem = -1;        return mouseMove(evt, x, y);    }        public boolean mouseDown(Event evt, int x, int y) {        try {            String u = null;            if (curMenuItem >= 0 && itemUrl[curMenu].length > 0) {                u = itemUrl[curMenu][curMenuItem];            } else if (curMenu >= 0) {                u = url[curMenu];            }            if (u != null) {                URL url = new URL (getDocumentBase(), u);                if (getParameter("target") != null) {	            getAppletContext().showDocument(url, getParameter("target"));                } else {	            getAppletContext().showDocument(url);                }            }        } catch (Exception e) {            e.printStackTrace();        }        return true;    }    public boolean mouseMove(Event evt, int x, int y) {        if (curMenu >= 0) {            int sm = inMenu(menuItemRect, x, y);	    	if (curMenuItem != sm) {				curMenuItem = sm;				repaint();	    	}            if (sm >= 0) {                return true;            }            //curMenu = -1;        }        int m = inMenu(hitArea, x, y);        if (m != curMenu) {            curMenu = m;            // A new menu is now active so compute menuItemRect.            if (m >= 0) {                // Minimum width                int maxWidth = 50;                    int maxHeight = 0;    				curMenuItem = -1;                menuItemRect = new Rectangle[item[curMenu].length];                for (int i=0; i<menuItemRect.length; i++) {                    String[] line = parse(item[curMenu][i], "^");                    for (int j=0; j<line.length; j++) {                        int w = fm.stringWidth(line[j]);                        if (w > maxWidth) {                            maxWidth = w;                        }                    }                    menuItemRect[i] = new Rectangle();                    menuItemRect[i].height =                         parse(item[curMenu][i], "^").length * fm.getHeight()                        + marginV;					//menuItemRect[i].height = 20;                    maxHeight += menuItemRect[i].height;                }	        	// Determine domain of submenus                // Add one extra pixel for the left edge.				maxWidth +=  2 * marginH + 1;                if (down[m]) {                    y = Math.max(0, Math.min(size().height-maxHeight-1,                         dstPt[curMenu].y + srcRect[curMenu].height-1));                } else {                    y = Math.max(0, Math.min(size().height-maxHeight-1,                         dstPt[curMenu].y - maxHeight));                }				x = dstPt[curMenu].x + srcRect[curMenu].width-maxWidth-1;	       		for (int i=0; i<item[curMenu].length; i++) {                    menuItemRect[i].x = x;                    menuItemRect[i].y = y;                    menuItemRect[i].width = maxWidth;                    y += menuItemRect[i].height;	        	}	        	getAppletContext().showStatus(url[curMenu]);            }            repaint();        }        return true;    }    // Returns the index of the rectangle in rs containing x and y.    // Returns -1 if either rs is null or x and y is not in rs.    int inMenu(Rectangle[] rs, int x, int y) {        if (rs != null) {            for (int i=0; i<rs.length; i++) {                if (rs[i].inside(x, y)) {                    return i;                }            }        }        return -1;    }}