/*
 * PCFDemo3.java
 *      A simple demonstration of PCFFont, showing off some text effects.
 *      Usage:  <applet code="PCFDemo3.class width=100 height=100>
 *              </applet>
 *
 * Ken Shirriff         ken.shirriff@eng.sun.com
 *
 * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
 *
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
 * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
 * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 *
 * Please refer to the file "license.txt"
 * for further important copyright and licensing information.
 */

import java.awt.*;
import java.awt.image.*;
import java.applet.Applet;
import java.net.*;
import java.util.*;
import java.io.*;
import pcffont.*;

public class PCFDemo3 extends Applet {
	PCFFont font1; // Current font
	Image backImg, img2, img3;
	Image bgImg;
	Image tmpImg;
	int dispWidth, dispHeight;
	Choice font_selector;
	int fontnum = 0;
	TextField tf;
	Fontlist fontlist;

	// Set up the user interface
	public void init() {
		String fontlistfile = getParameter("fontlist");
		String imgs1 = getParameter("img1");
		String imgs2 = getParameter("img2");
		String imgs3 = getParameter("img3");
		try {
			fontlist = new Fontlist(getDocumentBase(), fontlistfile);
		} catch (IOException e) {
			showStatus("read error "+e);
			return;
		}

		bgImg = getImage(getDocumentBase(), imgs1);
		img2 = getImage(getDocumentBase(), imgs2);
		img3 = getImage(getDocumentBase(), imgs3);


                showStatus("Loading font...");
		fontnum = fontlist.lookupFont(getParameter("defaultfont"));
		if (fontnum < 0) {
			fontnum = 0;
		}
		font1 = fontlist.openfont(fontnum);
                showStatus("");

		waitImage(bgImg);
		waitImage(img2);
		waitImage(img3);

		font1.setFgColor(Color.black);
		font1.setBgColor(null);

                // Compute the size of the display and create the image buffer
                dispWidth = size().width;
                dispHeight = size().height;

		Panel p = new Panel();
		setLayout(new BorderLayout());
		add("South", p);
		font_selector = new Choice();
		for (int i=0;i<fontlist.getNumFonts(); i++) {
			font_selector.addItem(fontlist.getNames()[i]);
		}
		font_selector.select(fontnum);
		tf = new TextField("Greetings", 20);
		p.add(font_selector);
		p.add(tf);

		repaint();
	}

	public boolean handleEvent(Event e) {
		if (e.target.equals(font_selector)) {
			int index = font_selector.getSelectedIndex();
			if (index != fontnum) {
				showStatus("Loading font...");
				font1 = fontlist.openfont(index);
				showStatus("");
				fontnum = index;
				backImg = null;
				repaint();
			}
		} else if (e.target.equals(tf) && e.id == Event.ACTION_EVENT) {
			backImg = null;
			repaint();
		}
		return super.handleEvent(e);
	}

	public void update(Graphics g) {
		paint(g);
	}

	// Paint the text into backImg the first time, and after that just
	// redisplay backImg.
	public void paint(Graphics g1) {
		int height = font1.getHeight()+8;
		int ypos = height;
		int xpos = 20;

		if (backImg == null) {
		String str = tf.getText();

                backImg = createImage(dispWidth, dispHeight);
		Graphics g = backImg.getGraphics();

		// bgImg is the background
		pattern(g, bgImg, dispWidth, dispHeight);

		getGraphics().drawImage(backImg, 0, 0, null);

		Image strImg = font1.stringImage(str);
		waitImage(strImg);
		PCFMetrics strMetrics = font1.stringMetrics(str);

		// fillImg is the text filled in with img2
		Image fillImg = select(strImg,img2);

		// Draw filled text
		g.drawImage(fillImg, xpos, ypos-strMetrics.ascent, null);
		ypos += height;


		// Draw outline by drawing text shifted up, down, left, right
		font1.setFgColor(Color.red);
		font1.setBgColor(null);
		for (int x=-1;x<=1;x++) {
			for (int y=-1;y<=1;y++) {
				font1.drawString(g, str, xpos+x, ypos+y);
			}
		}
		g.drawImage(fillImg, xpos, ypos-strMetrics.ascent, null);
		ypos += height;

		// Draw outline with drop shadow
		font1.setFgColor(Color.blue);
		font1.setBgColor(null);
		for (int x=-2;x<=2;x++) {
			for (int y=-2;y<=2;y++) {
				font1.drawString(g, str, xpos+x, ypos+y);
			}
		}
		font1.setFgColor(Color.white);
		font1.drawString(g, str, xpos, ypos);
		font1.setFgColor(Color.black);
		font1.drawString(g, str, xpos+2, ypos+1);
		ypos += height;

		getGraphics().drawImage(backImg, 0, 0, null);

		// Draw shadowed filled
		font1.setFgColor(Color.black);
		font1.drawString(g, str, xpos-2, ypos-2);
		g.drawImage(fillImg, xpos, ypos-strMetrics.ascent, null);
		ypos += height;

		// Draw drop shadow with fade
		fillImg = select(strImg,mkFade(font1.getHeight()));
		g.drawImage(fillImg, xpos, ypos-strMetrics.ascent, null);
		ypos += height;

		// Use another foreground
		// Draw outline
		font1.setFgColor(Color.black);
		font1.setBgColor(null);
		for (int x=-2;x<=2;x++) {
			for (int y=-2;y<=2;y++) {
				font1.drawString(g, str, xpos+x, ypos+y);
			}
		}
		fillImg = select(strImg,img3);
		g.drawImage(fillImg, xpos, ypos-strMetrics.ascent, null);
		ypos += height;

		g1.drawImage(backImg, 0, 0, null);

		// Start new column
		ypos = height;
		xpos = strMetrics.rightSideBearing+50;

		Image img;

		// Draw blurred
		double conv[][] = convolve(strImg, mkmask(mask_blur1));
		g.drawImage(toImage(conv,0), xpos, ypos-strMetrics.ascent, null);
		font1.drawString(g, str, xpos+2, ypos+2);
		ypos += height;

		g1.drawImage(backImg, 0, 0, null);

		// Draw blurred
		conv = convolve(strImg, mkmask(mask_color));
		g.drawImage(reflect(conv), xpos, ypos-strMetrics.ascent, null);
		ypos += height;

		g1.drawImage(backImg, 0, 0, null);

		// Draw blurred
		conv = convolve(strImg, mask_emboss);
		g.drawImage(toImage(conv,.5), xpos, ypos-strMetrics.ascent, null);
		ypos += height;

		g1.drawImage(backImg, 0, 0, null);

		conv = convolve(strImg, mkmask(mask_clip));
		// Eat away at the image.  We have to guess a good clipping level.
		double sum=0, num=0;
		for (int x=0;x<conv.length;x++) {
			for (int y=0;y<conv[0].length;y++) {
				if (conv[x][y]>.5) {
					sum += conv[x][y];
					num++;
				}
			}
		}
		double level = .5;
		if (sum>0) {
			level = sum/num;
		}
		img = clip(conv, level, 1);
		g.drawImage(img, xpos, ypos-strMetrics.ascent, null);
		ypos += height;

		g1.drawImage(backImg, 0, 0, null);

		// Color the blurred image
		conv = convolve(strImg, mkmask(mask_color));
		img = recolor(conv, 0);
		g.drawImage(img, xpos, ypos-strMetrics.ascent, null);
		ypos += height;

		g1.drawImage(backImg, 0, 0, null);

		// Color the blurred image again
		conv = convolve(strImg, mkmask(mask_color));
		img = recolor(conv, 1);
		g.drawImage(img, xpos, ypos-strMetrics.ascent, null);
		ypos += height;
		}

		g1.drawImage(backImg, 0, 0, null);
	}

	// 1d convolution masks
	double mask_blur1[] = {.2,0,0,0,.2};
	double mask_blur2[] = {.15,0,0,0,.15};
	double mask_clip[] = {.1,0,0,0,.1};
	double mask_color[] = {.1,0,.1,0,.1};

	double mask_emboss[][] = {{-.1,-.1,0}, {-.1,0,.1}, {0,.1,.1}};

	// Make 2d convolution mask from a 1d mask
	double[][] mkmask(double mask1[]) {
		int sz = mask1.length;
		int off = (sz-1)/2;
		double mask2[][] = new double[sz][];

		for (int i=0; i<sz; i++) {
			mask2[i] = new double[sz];
			for (int j=0; j<sz; j++) {
				int r = (int)(Math.sqrt(
				    (i-off)*(i-off)+(j-off)*(j-off))+.9);
				if (off+r<sz) {
					mask2[i][j] = mask1[off+r];
				}
			}
		}
		return mask2;
	}

	Image waitImage(Image i) {
		MediaTracker tracker = new MediaTracker(this);
		tracker.addImage(i, 1);
		while (!tracker.checkAll()) {
			try {
				tracker.waitForAll();
			} catch (Exception e) {}
		}
		return i;
	}

	Image mkFade(int h) {
		int i1b[] = new int[h];
		for (int i=0;i<h;i++) {
			int r = 255;
			int g = 255*i/(h-1);
			int b = 255*(h-i-1)/(h-1);
			i1b[i] = (0xff<<24)|(r<<16)|(g<<8)|(b<<0);
		}
		return waitImage(Toolkit.getDefaultToolkit().createImage(new
				    MemoryImageSource(1,h,i1b,0,1)));
	}

	// Convolve the image with the mask
	// Return a double array
	double[][] convolve(Image i1, double mask[][]) {
		int sz = mask[0].length;
		int off = (sz-1)/2;
		int i1w = i1.getWidth(null);
		int i1h = i1.getHeight(null);
		int i2w = i1w+sz-1;
		int i2h = i1h+sz-1;
		int i1b[] = new int[i1w*i1h];
		double s[][] = new double[i2w][];
		PixelGrabber pg1 = new PixelGrabber(i1, 0, 0, i1w, i1h, i1b,
		    0, i1w);
		try {
			pg1.grabPixels();
		} catch (Exception e) {}
		for (int x=0;x<i2w;x++) {
			s[x] = new double[i2h];
		}
		for (int x=0;x<i1w;x++) {
			for (int y=0;y<i1h;y++) {
				if (i1b[x+y*i1w] != 0) {
					for (int xx=0;xx<sz;xx++) {
						for (int yy=0;yy<sz;yy++) {
							s[x+xx][y+yy] += mask[xx][yy]+0.0000001;
						}
					}
				}
			}
		}
		return s;
	}

	// Convert the convolution file to an image
	Image toImage(double s[][], double offset) {
		int w = s.length;
		int h = s[0].length;
		int i1b[] = new int[w*h];
		for (int x=0;x<w; x++) {
			for (int y=0; y<h; y++) {
				double f = s[x][y]+offset;
				if (f == 0) {
					i1b[x+y*w] = 0;
				} else {
					if (f<0) {
						f = 0;
					} else if (f>1) {
						f = 1;
					}
					int r = (int)(255*(1-f));
					i1b[x+y*w] = (0xff<<24)|(r<<16)|(r<<8)|(r<<0);
				}
			}
		}
		return waitImage(Toolkit.getDefaultToolkit().createImage(new
				    MemoryImageSource(w,h,i1b,0,w)));
	}

	// Use i1 as a mask to select pixels from i2 where i1 != 0
	Image select(Image i1, Image i2) {
		int i1w = i1.getWidth(null);
		int i2w = i2.getWidth(null);
		int i1h = i1.getHeight(null);
		int i2h = i2.getHeight(null);
		int i1b[] = new int[i1w*i1h];
		int i2b[] = new int[i2w*i2h];
		PixelGrabber pg1 = new PixelGrabber(i1, 0, 0, i1w, i1h, i1b,
		    0, i1w);
		PixelGrabber pg2 = new PixelGrabber(i2, 0, 0, i2w, i2h, i2b,
		    0, i2w);
		try {
			pg1.grabPixels();
			pg2.grabPixels();
		} catch (Exception e) {}
		for (int x=0;x<i1w;x++) {
			for (int y=0;y<i1h;y++) {
				if ((i1b[x+y*i1w]>>>24)==0xff) {
					int xx = x%i2w;
					int yy = y%i2h;
					i1b[x+y*i1w] = i2b[(x%i2w)+(y%i2h)*i2w];
				} else {
					i1b[x+y*i1w] = 0;
				}
			}
		}
		return waitImage(Toolkit.getDefaultToolkit().createImage(new
				    MemoryImageSource(i1w,i1h,i1b,0,i1w)));
	}

	// Clip image at val
	Image clip(double s[][], double min, double max) {
		int i1w = s.length;
		int i1h = s[0].length;
		int i1b[] = new int[i1w*i1h];
		for (int x=0;x<i1w;x++) {
			for (int y=0;y<i1h;y++) {
				double f = s[x][y];
				if (f==0 || f<min || f>max) {
					i1b[x+y*i1w] = 0;
				} else {
					i1b[x+y*i1w] = 0xff000000;
				}
			}
		}
		return waitImage(Toolkit.getDefaultToolkit().createImage(new
				    MemoryImageSource(i1w,i1h,i1b,0,i1w)));
	}

	// Reflect
	Image reflect(double s[][]) {
		int i1w = s.length;
		int i1h = s[0].length;
		int i1b[] = new int[i1w*i1h];
		for (int x=2;x<i1w-2;x++) {
			for (int y=2;y<i1h-2;y++) {
				double xn = -s[x-2][y]-s[x-1][y]+s[x][y]+s[x+1][y];
				double yn = -s[x][y-2]-s[x][y-1]+s[x][y]+s[x][y+1];
				if (s[x][y] == 0 && xn==0 && yn==0) {
					continue;
				}
				xn = xn-.15*(x/(double)i1w-.5);
				yn = yn-.15*(y/(double)i1h-.5);
				int r = (int)(140+xn*100);
				int g = (int)(140+yn*100);
				int b;
				if (xn+yn>.01) {
					b = 200;
				} else {
					b = 100;
				}
				if (r>255) {
					r = 255;
				}
				if (r<0) {
					r = 0;
				}
				if (g>255) {
					g = 255;
				}
				if (g<0) {
					g = 0;
				}
				i1b[x+y*i1w] = (0xff<<24)|(r<<16)|(g<<8)|(b<<0);
			}
		}
		return waitImage(Toolkit.getDefaultToolkit().createImage(new
				    MemoryImageSource(i1w,i1h,i1b,0,i1w)));
	}

	// Recolor image
	Image recolor(double s[][], int mode) {
		int i1w = s.length;
		int i1h = s[0].length;
		int i1b[] = new int[i1w*i1h];
		for (int x=0;x<i1w;x++) {
			for (int y=0;y<i1h;y++) {
				double f = s[x][y];
				if (f==0) {
					i1b[x+y*i1w] = 0;
				} else {
					int r,g,b;
					if (mode==0) {
						if (f<0) {
							f = 0;
						} else if (f>1) {
							f = 1;
						}
						r = (int)(255*f);
						g = 255-r;
						b = r/2;
						i1b[x+y*i1w] = 0xff000000|(r<<16)|(g<<8)|b;
					} else {
						double brk = .4;
						double w = .5;
						double d;
						f -= brk-w;
						if (f>w) {
							f =  2*w-f;
						}
						f = f/w;
						if (f>0 && f<1) {
							r = 255;
							g = 255-(int)(100*f);
							b = 100-(int)(100*f);
							i1b[x+y*i1w] = 0xff000000|(r<<16)|(g<<8)|b;
						} else {
							i1b[x+y*i1w] = 0;
						}
					}
				}
			}
		}
		return waitImage(Toolkit.getDefaultToolkit().createImage(new
				    MemoryImageSource(i1w,i1h,i1b,0,i1w)));
	}

	// Fill g with Image i
	void pattern(Graphics g, Image i, int gwidth, int gheight) {
		int iwidth = i.getWidth(null);
		int iheight = i.getHeight(null);
		for (int x=0; x<gwidth; x += iwidth) {
			for (int y=0; y<gheight; y += iheight) {
				g.drawImage(i, x, y, null);
			}
		}
		
	}

        public String getAppletInfo() {
                return "PCFDemo3 by Ken Shirriff  shirriff@eng.sun.com";
        }
 
}