用applet写的菜单程序 machine.txt

用Applet写的菜单程序 machine

前几天在java.sun.com上看见一个用Applet写的菜单程序。由于Applet目前不支持Menu( 
据我所知）,: 也许这个程序对你有些帮助。 
原来的程序好像不完整，无法编译，我特地到java.sun.com上又载了一个， 
source如下： 
/* 
Copyright: Sun Microsystems 1997. All rights reserved. 
Author: Patrick Chan (www.xeo.com) 7/19/96 
Version: 1.1 
*/ 

import java.applet.*; 
import java.awt.*; 
import java.util.*; 
import java.net.*; 

public class XeoMenu 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; 

// 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; 

// 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 highlig 
hted // 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 String[] fields = parse(getParameter("menu"+i), getParameter("separ 
ator")); 
// Get the hit area. 
ints = parseInt(fields[0], " "); 
hitArea[i] = new Rectangle(ints[0], ints[1], ints[2], 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][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[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[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) { 
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(); 
// 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(); 

g2 = bbuf.getGraphics(); 
for (int i=0; i drawMenuItem(g2, i); 
} 
g2.dispose(); 
} 
g.drawImage(bbuf, 0, 0, this); 
} 

void drawMenuItem(Graphics g, int i) { 
int x, y, w, height; 
// break the menu item label into lines. 
String[] line = parse(item[curMenu][i], getParameter("newline")); 

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); 
y = menuItemRect[i].y + marginV; 
for (i=0; i g.drawString(line[i], 
menuItemRect[i].x+menuItemRect[i].width-fm.stringWidth(line[i]) 
-marginH, y + fm.getAscent()); 
y += fm.getHeight(); 
} 
} 

public boolean mouseExit(Event evt, int x, int y) { 
curMenuItem = curMenu = -1; 
repaint(); 
return true; 
} 

public boolean mouseEnter(Event evt, int x, int y) { 
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; 

menuItemRect = new Rectangle[item[curMenu].length]; 
for (int i=0; i String[] line = parse(item[curMenu][i], "^"); 

for (int j=0; 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() 
+ 2 * marginV; 
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 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 if (rs[i].inside(x, y)) { 
return i; 
} 
} 
} 
return -1; 
} 
}