Re: button factory

t b dinesh wrote:
> What is this button factory servlet?
> Where can I find it?
>
>
> >       *#<IMG SRC="${req.contextPath}/button_factory?#*
> >          *#textColor=FFFFFF&bgColor=${accentcolor}#*
> >          *#&text=${utils.escapeForURL($buttontext)}">#*
>
>
> > P.S. I see that you are using a button factory, is this based on my code? 
> > Cheers!
> >      As I've stated somewhere in some list the past (turbine, velocity,other?),
> >      it is intended to be published, can someone take a lead on this to get it
> >      into jakarta or sourceforge? I could also do this if someone points me in
> >      the right direction (jakarta account?).

See the attachment.

In the webapp and web.xml I mapped the servlet to a simple name
    <servlet>
        <servlet-name>button</servlet-name>
        <servlet-class>de.dlr.dfd.muiswww.servlets.ButtonFactory</servlet-class>
    </servlet>

And use it out of velocity, e.g.:
...
#set( $button = 
"/button?fontSize=16&width=110&height=26&insetH=0&insetV=0&fgColor=0xFFFFFF&buttonColor=0x333333&borderColor=0x404040"
 )

...
        <img src="$button&text=Home" alt="Home" border="0"></a>


Please give feedback if you think this should go into Jakarta or sourceforge...


You can try it out live at:
  http://piglet.esrin.esa.it:8080/eoweb/servlets/button?text=Hello%20World!
PLEASE NO LIVE LINKS TO THIS SITE. I HAVE PROVIDED THE SOURCE IN THE
ATTACHMENT SO YOU CAN INSTALL IT ON YOUR SITE.

If you use something prior to JDK 1.4, you will need to start the servlet
container (Tomcat) with a proper DISPLAY environment set, for example:
   setenv DISPLAY localhost:1
with a virtual X frame buffer (xvfb in the XFree X11r6 delivery), to be able
to use the headless Swing clases.

--
:) Christoph Reck
// --------------------------------------------------------------------
/*
 *  File:     ButtonFactory
 *
 *  $RCSfile: ButtonFactory.java,v $
 *  $Revision: 1.0 $
 *  $Date: 2001-04-10 $
 *
 *  Author: Christoph.Reck@xxxxxx
 *
 *  Copyright DLR 2000, 2001
 *
 */
// --------------------------------------------------------------------

package de.dlr.dfd.muiswww.servlets;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.*;
import java.awt.*;
import java.awt.image.*;
import java.awt.geom.Rectangle2D;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import javax.swing.Icon;
import javax.swing.SwingUtilities;
import javax.swing.plaf.basic.BasicGraphicsUtils;
import com.sun.image.codec.jpeg.JPEGImageEncoder;
import com.sun.image.codec.jpeg.JPEGCodec;

import de.dlr.dfd.muiswww.util.GifEncoder;

/**
 * This servlet class generates buttons dynamically.<p>
 *
 * The permitted URI parameters are:<br>
 * <dl>
 *   <dd>text=a+string</dd>
 *     <dt>the text to place on the button (use URL escaping)</dt>
 *   <dd>fontStyle=Bold | Italic</dd>
 *     <dt>the text font style (default=Normal)</dt>
 *   <dd>fontSize=14</dd>
 *     <dt>the size of the text in pixels</dt>
 *   <dd>insetH=4</dd>
 *     <dt>additional horizontal space left and right of text</dt>
 *   <dd>insetV=1</dd>
 *     <dt>additional vertical spaceabove and below the text</dt>
 *   <dd>width=50</dd>
 *     <dt>specifies a fixed width (default is to use the text</dt>
 *     width + insetH), minimum is 18x18</dt>
 *   <dd>heigth=24</dd>
 *     <dt>secifies a fixed height instead of computed default</dt>
 *   <dd>border=2</dd>
 *     <dt>border outside of button, or left/right of tabs (with
 *     a border < 2, the button border will not be drawn)</dt>
 *   <dd>tab=false|true</dd>
 *     <dt>format the button to look like a tab</dt>
 *   <dd>pressed=false|true</dd>
 *     <dt>make tab pressed (no separating line on bottom of a tab)</dt>
 *   <dd>buttonColor=0xCCCCCC</dd>
 *     <dt>the color of the button surface</dt>
 *   <dd>fgColor=0x003399</dd>
 *     <dt>the color for the button text</dt>
 *   <dd>bgColor=0x333333</dd>
 *     <dt>the color of the area around the button or tab</dt>
 *   <dd>transparent=0x333333</dd>
 *     <dt>the color that shall be marked as transparent</dt>
 *     (currently only 0, 1 or 0x333333 work properly)</dt>
 *   <dd>borderColor=0x404040</dd>
 *     <dt>the color of the button border</dt>
 *   <dd>borderHighlite=0x808080</dd>
 *     <dt>the color of the highlighted button border</dt>
 * </dl>
 * The list is in order of importance, parameters that are not supplied
 * are filled by defaults.<p>
 *
 * <font color="red">Note:</font> The HTTP server will need to
 * be run in an environment that permits the AWT to get hold of
 * a graphic context (e.g. a X-server running).
 *
 * @author Christoph.Reck@xxxxxx
 */
public class ButtonFactory extends HttpServlet
{
  private static final String TR_COLOR = "#333333"; // transparent
  private static final String BG_COLOR = "#333333"; // background: transparent
  private static final String BT_COLOR = "#CCCCCC"; // button:     gray
  private static final String FG_COLOR = "#000000"; // foreground: black
  private static final String BD_COLOR = "#666666"; // border:     dark gray
  private static final String HL_COLOR = "#EEEEEE"; // highlight:  light gray

  /**
   * Utilitiy to read a parameter from the http request.
   *
   * @param request      The HttpServletRequest request.
   * @param name         The name of the parameter.
   * @param defaultValue Used when the parameter was not supplied.
   */
  private static String getParameter(
    HttpServletRequest request, String name, String defaultValue )
  {
    String param = request.getParameter(name);
    return (param == null) ? defaultValue : param;
  }

  /**
   * Utility to convert a string into an integer value,
   * Hexadecimal numbers are indicated by the prefixes "0x" and "#"
   * (as commonly used in HTML pages to denote colors).
   */
  public static int convertToInt(String str)
  {
    if ( str.startsWith("0x") )
      return Integer.parseInt(str.substring(2), 16);
    else if ( str.startsWith("#") )
      return Integer.parseInt(str.substring(1), 16);
    else
      return Integer.parseInt(str);
  }

  /**
   * Transfrom a string into a <code>Color</code> instance, is tuse the
   * above <code>convertToInt</code> method to convert it first into
   * an RGB integer.
   *
   * @see convertToInt
   */
  public static Color convertToColor(String colorStr)
  {
    return new Color( convertToInt(colorStr) );
  }

  /**
   * The HTTP GET request handler.
   */
  public void doGet(HttpServletRequest request, HttpServletResponse response)
              throws IOException
  {

    PrintWriter out = response.getWriter();

    try {
      BufferedImage img = null;
      Graphics g = null;
      FontMetrics fontMetrics = null;
      Font font = null;

      // get text
      String text = getParameter(request, "text", "OK");

      // get background
      //## String data = readFile(request, "images/naomic.gif");
      Icon icon = null;

      // decode font
      String fontName = getParameter(request, "fontName", "Dialog");
      String fontStyle = getParameter(request, "fontStyle", "");
      int fontSize = Integer.parseInt( getParameter(request, "fontSize", "14") 
);
      int style =
          (((fontStyle.indexOf('B') >= 0) ||
            (fontStyle.indexOf('b') >= 0)) ? Font.BOLD : Font.PLAIN)
        | (((fontStyle.indexOf('I') >= 0) ||
            (fontStyle.indexOf('i') >= 0)) ? Font.ITALIC : Font.PLAIN);
      font = new Font(fontName, style, fontSize);

      // decode size
      int border = Integer.parseInt( getParameter(request, "border", "2") );
      if (border < 0) border = 0;
      int insetH = Integer.parseInt( getParameter(request, "insetH", "10") );
      int insetV = Integer.parseInt( getParameter(request, "insetV", "1") );
      // these are the current minimum sizes
      int width  = 18;
      int height = 18;
      // retrieve font metrics to determine minimum height
      img = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_INDEXED);
      g = img.createGraphics();
      g.setFont(font);
      fontMetrics = g.getFontMetrics();
      g.dispose();
      int x = SwingUtilities.computeStringWidth(fontMetrics, text)
        + 2*border + 2*insetH;
      int y = fontMetrics.getHeight() + 2*border + 2*insetV;
      int w = Integer.parseInt( getParameter(request, "width", "" + x) );
      int h = Integer.parseInt( getParameter(request, "height", "" + y) );
      if ( (w > width) || (h > height) || (y > height) )
      {
        // adjust only the ones that need it
        if (w > width) width = w;
        if (h > height) height = h;
        if (y > height) height = y;
        img = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_INDEXED);
      }

      // decode colors
      Color fgColor = Color.decode(
        getParameter(request, "fgColor", FG_COLOR ) );
      Color bgColor = Color.decode(
        getParameter(request, "bgColor", BG_COLOR ) );
      Color buttonColor = convertToColor(
        getParameter(request, "buttonColor", BT_COLOR ) );
      Color borderColor = Color.decode(
        getParameter(request, "borderColor", BD_COLOR ) );
      Color borderHighlite = Color.decode(
        getParameter(request, "borderHighlite", HL_COLOR) );
      int transparent = convertToInt(
        getParameter(request, "transparent", TR_COLOR) );

      // decode button state
      boolean enabled = Boolean.valueOf(
        getParameter(request, "enabled", "true") ).booleanValue();
      boolean pressed = Boolean.valueOf(
        getParameter(request, "pressed", "false") ).booleanValue();
      boolean tabShape = Boolean.valueOf(
        getParameter(request, "tab", "false") ).booleanValue();

      // build button
      g = img.createGraphics();
      g.setFont(font);
      fontMetrics = g.getFontMetrics();

      Rectangle iconR = new Rectangle(0, 0, 0, 0);
      Rectangle textR = new Rectangle(0, 0, 0, 0);
      Rectangle viewR =
        new Rectangle(insetH, insetV, width - 2*insetH, height - 2*insetV);
      String clippedText = SwingUtilities.layoutCompoundLabel(
        fontMetrics,
        text,
        icon,
        SwingUtilities.CENTER,  // VerticalAlignment
        SwingUtilities.CENTER,  // HorizontalAlignment
        SwingUtilities.CENTER,  // VerticalTextPosition
        SwingUtilities.CENTER,  // HorizontalTextPosition
        viewR,
        iconR,
        textR,
        0 );

      // draw background and border
      g.setColor(bgColor);
      g.fillRect(0, 0, width, height);
      if (tabShape)
      {
        int x1 = border;
        int x2 = (height - 2*border)/2;
        int x3 = width - x2;
        int x4 = width - border;
        int y1 = height - 2; // border does not affect Y
        int y2 = 2;

        // draw tab
        if( (text != null) && (text.length() != 0) )
        {
          g.setColor(buttonColor);
          g.fillPolygon( new int[] {x1 - 1, x2 - 1, x3 + 1, x4 + 1},
            new int[] {y1, y2, y2, y1}, 4 );
        }

        // draw bottom line (selected or unselected)
        g.setColor((pressed) ? buttonColor : borderHighlite);
        g.drawLine(x1 - 1, y1, x4 + 1, y1); // bottom line
        g.setColor((pressed) ? buttonColor : borderColor);
        g.drawLine(x1 - 2, y1 + 1, x4 + 2, y1 + 1);

        // draw bezel tab border
        if( (text != null) && (text.length() != 0) )
        {
          g.setColor(borderHighlite);
          g.drawLine(x1 - 2, y1 - 1, x2 - 2, y2    ); // up
          g.drawLine(x2 - 1, y2 - 2, x3    , y2 - 2); // right
          g.setColor(borderHighlite.darker());
          g.drawLine(x1 - 1, y1 - 1, x2 - 1, y2    ); // up
          g.drawLine(x2 - 1, y2 - 1, x3 + 1, y2 - 1); // right
          g.setColor(borderColor.darker());
          g.drawLine(x3 + 1, y2    , x4 + 1, y1    ); // down
          g.setColor(borderColor);
          g.drawLine(x3 + 2, y2    , x4 + 2, y1    ); // down
        }

        // tab connector line
        if (!pressed || (border > 2))
        {
          g.setColor(borderHighlite);
          g.drawLine(0     , y1, x1 - 2, y1);
          g.drawLine(x4 + 2, y1, width , y1);
          g.setColor(borderColor);
          g.drawLine(0     , y1 + 1, x1 - 3, y1 + 1);
          g.drawLine(x4 + 2, y1 + 1, width , y1 + 1);
        }
      }
      else
      {
        g.setColor(buttonColor);
        g.fillRect(border, border, width - 2*border, height - 2*border);
        if (border >= 2)
        {
          BasicGraphicsUtils.drawBezel( g,
            border - 2, border - 2,
            width - 2*border + 4, height - 2*border + 4,
            pressed, false,
            borderColor.darker(), borderColor,
            borderHighlite, borderHighlite.brighter()
          );
        }
      }

//##    if (icon != null)
//##      icon.paintIcon(c, g, iconR.x, iconR.y);

      if( (text != null) && (text.length() != 0) )
      {
        int textX = textR.x;
        int textY = textR.y + fontMetrics.getAscent();
        if (enabled)
        {
          g.setColor(fgColor);
        }
        else
        {
          g.setColor(bgColor.brighter());
          g.drawString(clippedText, textX + 1, textY + 1);
          g.setColor(bgColor.darker());
        }
        g.drawString(clippedText, textX, textY);
      }

      g.dispose();

      // prepare buffer with typical button data size
      ByteArrayOutputStream buf = new ByteArrayOutputStream(1200);

      // decide what we should return
      String format = getParameter(request, "format", "gif");
      if ( format.equalsIgnoreCase("jpeg") )
      {
        JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(buf);
        encoder.encode(img);
        response.setContentType("image/jpeg");
      }
      else
      {
        GifEncoder encoder = new GifEncoder(img);
        if (transparent >= 0)
        {
          //## not wroking properly, e.g. only works with 0x000000 and 0x333333
          encoder.setTransparentRGB(transparent);
        }
        encoder.write(buf);
        response.setContentType("image/gif");
      }

      out.write( buf.toString( response.getCharacterEncoding() ) );

    }
    catch (Exception ex)
    {
      response.setContentType("text/plain");
      out.write("An error ocurred\n");
      ex.printStackTrace(out);
    }
  } // end of doGet

} // end of ButtonFactory
/**  GifEncoder - writes out an image as a GIF.
 *
 * Transparency handling and variable bit size courtesy of Jack Palevich.
 *
 * Copyright (C) 1996 by Jef Poskanzer <jef@xxxxxxxx>.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * Visit the ACME Labs Java page for up-to-date versions of this and other
 * fine Java utilities: http://www.acme.com/java/
 */

package de.dlr.dfd.muiswww.util;

import java.util.*;
import java.io.*;
import java.awt.Image;
import java.awt.image.*;

/**
 * Adapted by Christoph.Reck@xxxxxx to support transparency.
 */
public class GifEncoder
{
    private boolean interlace = false;
    private int transparentRGB = -1;
    private int width, height;
    private byte[] pixels;
    private byte[] r, g, b; // the color look-up table
    private int pixelIndex;
    private int numPixels;

    /**
    *  Constructs a new GifEncoder.
    * @param width      The image width.
    * @param height     The image height.
    * @param pixels     The pixel data.
    * @param r          The red look-up table.
    * @param g          The green look-up table.
    * @param b          The blue look-up table.
    */
    public GifEncoder( int width, int height, byte[] pixels,
                       byte[] r, byte[] g, byte[] b )
    {
        this.width = width;
        this.height = height;
        this.pixels = pixels;
        this.r = r; this.g = g; this.b = b;
        interlace = false;
        pixelIndex = 0;
        numPixels = width*height;
    }

    /**
     * Constructs a new GifEncoder using an 8-bit AWT Image.
     * The image is assumed to be fully loaded.
     */
    public GifEncoder(Image img)
    {
        width = img.getWidth(null);
        height = img.getHeight(null);
        pixels = new byte[width * height];
        PixelGrabber pg = new PixelGrabber(img, 0, 0, width, height, false);
        try {
            pg.grabPixels();
        } catch (InterruptedException e) {
            System.err.println(e);
        };
        ColorModel cm = pg.getColorModel();
        if (cm instanceof IndexColorModel)
            pixels = (byte[])(pg.getPixels());
        else
            throw new IllegalArgumentException("Image must be 8-bit");
        IndexColorModel m = (IndexColorModel)cm;
        int transparentIndex = m.getTransparentPixel();
        if (transparentIndex >= 0)
          transparentRGB = m.getRGB(transparentIndex);
        int mapSize = m.getMapSize();
        r = new byte[mapSize];
        g = new byte[mapSize];
        b = new byte[mapSize];
        m.getReds(r);
        m.getGreens(g);
        m.getBlues(b);
        interlace = false;
        pixelIndex = 0;
        numPixels = width*height;
    }

    /**
     * Define the transparent color.
     *
     * @author Christoph.Reck@xxxxxx
     */
    public void setTransparentRGB(int transparentRGB)
    {
        this.transparentRGB = transparentRGB;
    }

    /** Saves the image as a GIF file. */
    public void write(OutputStream out) throws IOException
    {
        // Figure out how many bits to use.
        int numColors = r.length;
        int BitsPerPixel;
        if (numColors<=2)
            BitsPerPixel = 1;
        else if (numColors<=4)
            BitsPerPixel = 2;
        else if (numColors<=16)
            BitsPerPixel = 4;
        else
            BitsPerPixel = 8;

        int ColorMapSize = 1 << BitsPerPixel;
        byte[] reds = new byte[ColorMapSize];
        byte[] grns = new byte[ColorMapSize];
        byte[] blus = new byte[ColorMapSize];
        int transparencyIndex = -1;
        for (int i=0; i<numColors; i++) {
          reds[i] = r[i];
          grns[i] = g[i];
          blus[i] = b[i];
          if (transparentRGB != -1) {
            int color = (r[i] << 16) + (g[i] << 8)  + b[i];
            if (color == transparentRGB)
              transparencyIndex = i;
          }
        }

        GIFEncode(out, width, height, interlace, (byte) 0, transparencyIndex, 
BitsPerPixel, reds, grns, blus);
    }

    void writeString(OutputStream out, String str) throws IOException
    {
        byte[] buf = str.getBytes();
        out.write(buf);
    }

    // Adapted from ppmtogif, which is based on GIFENCOD by David
    // Rowley <mgardi@xxxxxxxxxxxxxxxxxxxx>.  Lempel-Zim compression
    // based on "compress".

    int Width, Height;
    boolean Interlace;

    void GIFEncode( OutputStream outs, int Width, int Height,
                    boolean Interlace, byte Background, int Transparent,
                    int BitsPerPixel, byte[] Red, byte[] Green, byte[] Blue )
        throws IOException
    {
        byte B;
        int LeftOfs, TopOfs;
        int ColorMapSize;
        int InitCodeSize;
        int i;

        this.Width = Width;
        this.Height = Height;
        this.Interlace = Interlace;
        ColorMapSize = 1 << BitsPerPixel;
        LeftOfs = TopOfs = 0;

        // The initial code size
        if ( BitsPerPixel <= 1 )
            InitCodeSize = 2;
        else
            InitCodeSize = BitsPerPixel;

        // Write the Magic header
        writeString( outs, "GIF89a" );

        // Write out the screen width and height
        Putword( Width, outs );
        Putword( Height, outs );

        // Indicate that there is a global colour map
        B = (byte) 0x80;      // Yes, there is a color map
        // OR in the resolution
        B |= (byte) ( ( 8 - 1 ) << 4 );
        // Not sorted
        // OR in the Bits per Pixel
        B |= (byte) ( ( BitsPerPixel - 1 ) );

        // Write it out
        Putbyte( B, outs );

        // Write out the Background colour
        Putbyte( Background, outs );

        // Pixel aspect ratio - 1:1.
        //Putbyte( (byte) 49, outs );
        // Java's GIF reader currently has a bug, if the aspect ratio byte is
        // not zero it throws an ImageFormatException.  It doesn't know that
        // 49 means a 1:1 aspect ratio.  Well, whatever, zero works with all
        // the other decoders I've tried so it probably doesn't hurt.
        Putbyte( (byte) 0, outs );

        // Write out the Global Colour Map
        for ( i = 0; i < ColorMapSize; ++i )
        {
            Putbyte( Red[i], outs );
            Putbyte( Green[i], outs );
            Putbyte( Blue[i], outs );
        }

        // Write out extension for transparent colour index, if necessary.
        if ( Transparent != -1 )
        {
            Putbyte( (byte) '!', outs );
            Putbyte( (byte) 0xf9, outs );
            Putbyte( (byte) 4, outs );
            Putbyte( (byte) 1, outs );
            Putbyte( (byte) 0, outs );
            Putbyte( (byte) 0, outs );
            Putbyte( (byte) Transparent, outs );
            Putbyte( (byte) 0, outs );
        }

        // Write an Image separator
        Putbyte( (byte) ',', outs );

        // Write the Image header
        Putword( LeftOfs, outs );
        Putword( TopOfs, outs );
        Putword( Width, outs );
        Putword( Height, outs );

        // Write out whether or not the image is interlaced
        if ( Interlace )
            Putbyte( (byte) 0x40, outs );
        else
            Putbyte( (byte) 0x00, outs );

        // Write out the initial code size
        Putbyte( (byte) InitCodeSize, outs );

        // Go and actually compress the data
        compress( InitCodeSize+1, outs );

        // Write out a Zero-length packet (to end the series)
        Putbyte( (byte) 0, outs );

        // Write the GIF file terminator
        Putbyte( (byte) ';', outs );
    }


    static final int EOF = -1;

    // Return the next pixel from the image
    int GIFNextPixel() throws IOException
    {
          if (pixelIndex==numPixels)
            return EOF;
        else
            return ((byte[])pixels)[pixelIndex++] & 0xff;
    }


    // Write out a word to the GIF file
    void Putword( int w, OutputStream outs ) throws IOException
    {
        Putbyte( (byte) ( w & 0xff ), outs );
        Putbyte( (byte) ( ( w >> 8 ) & 0xff ), outs );
    }

    // Write out a byte to the GIF file
    void Putbyte( byte b, OutputStream outs ) throws IOException
    {
        outs.write( b );
    }


    // GIFCOMPR.C       - GIF Image compression routines
    //
    // Lempel-Ziv compression based on 'compress'.  GIF modifications by
    // David Rowley (mgardi@xxxxxxxxxxxxxxxxxxxx)

    // General DEFINEs

    static final int BITS = 12;

    static final int HSIZE = 5003;      // 80% occupancy

    // GIF Image compression - modified 'compress'
    //
    // Based on: compress.c - File compression ala IEEE Computer, June 1984.
    //
    // By Authors:  Spencer W. Thomas      (decvax!harpo!utah-cs!utah-gr!thomas)
    //      Jim McKie      (decvax!mcvax!jim)
    //      Steve Davies   (decvax!vax135!petsd!peora!srd)
    //      Ken Turkowski  (decvax!decwrl!turtlevax!ken)
    //      James A. Woods   (decvax!ihnp4!ames!jaw)
    //      Joe Orost      (decvax!vax135!petsd!joe)

    int n_bits;            // number of bits/code
    int maxbits = BITS;            // user settable max # bits/code
    int maxcode;            // maximum code, given n_bits
    int maxmaxcode = 1 << BITS; // should NEVER generate this code

    final int MAXCODE( int n_bits )
    {
        return ( 1 << n_bits ) - 1;
    }

    int[] htab = new int[HSIZE];
    int[] codetab = new int[HSIZE];

    int hsize = HSIZE;      // for dynamic table sizing

    int free_ent = 0;            // first unused entry

    // block compression parameters -- after all codes are used up,
    // and compression rate changes, start over.
    boolean clear_flg = false;

    // Algorithm:  use open addressing double hashing (no chaining) on the
    // prefix code / next character combination.  We do a variant of Knuth's
    // algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
    // secondary probe.  Here, the modular division first probe is gives way
    // to a faster exclusive-or manipulation.  Also do block compression with
    // an adaptive reset, whereby the code table is cleared when the compression
    // ratio decreases, but after the table fills.  The variable-length output
    // codes are re-sized at this point, and a special CLEAR code is generated
    // for the decompressor.  Late addition:  construct the table according to
    // file size for noticeable speed improvement on small files.  Please direct
    // questions about this implementation to ames!jaw.

    int g_init_bits;

    int ClearCode;
    int EOFCode;

    void compress( int init_bits, OutputStream outs ) throws IOException
    {
        int fcode;
        int i /* = 0 */;
        int c;
        int ent;
        int disp;
        int hsize_reg;
        int hshift;

        // Set up the globals:  g_init_bits - initial number of bits
        g_init_bits = init_bits;

        // Set up the necessary values
        clear_flg = false;
        n_bits = g_init_bits;
        maxcode = MAXCODE( n_bits );

        ClearCode = 1 << ( init_bits - 1 );
        EOFCode = ClearCode + 1;
        free_ent = ClearCode + 2;

        char_init();

        ent = GIFNextPixel();

        hshift = 0;
        for ( fcode = hsize; fcode < 65536; fcode *= 2 )
            ++hshift;
        hshift = 8 - hshift;            // set hash code range bound

        hsize_reg = hsize;
        cl_hash( hsize_reg );      // clear hash table

        output( ClearCode, outs );

        outer_loop:
        while ( (c = GIFNextPixel()) != EOF )
        {
            fcode = ( c << maxbits ) + ent;
            i = ( c << hshift ) ^ ent;      // xor hashing

            if ( htab[i] == fcode )
            {
                ent = codetab[i];
                continue;
            }
            else if ( htab[i] >= 0 )      // non-empty slot
            {
                disp = hsize_reg - i;      // secondary hash (after G. Knott)
                if ( i == 0 )
                    disp = 1;
                do
                {
                    if ( (i -= disp) < 0 )
                      i += hsize_reg;

            if ( htab[i] == fcode )
            {
                ent = codetab[i];
                continue outer_loop;
            }
        }
        while ( htab[i] >= 0 );
        }
            output( ent, outs );
            ent = c;
            if ( free_ent < maxmaxcode )
            {
                codetab[i] = free_ent++;      // code -> hashtable
                htab[i] = fcode;
            }
            else
                cl_block( outs );
        }
        // Put out the final code.
        output( ent, outs );
        output( EOFCode, outs );
    }

    // output
    //
    // Output the given code.
    // Inputs:
    //      code:   A n_bits-bit integer.  If == -1, then EOF.  This assumes
    //      that n_bits =< wordsize - 1.
    // Outputs:
    //      Outputs code to the file.
    // Assumptions:
    //      Chars are 8 bits long.
    // Algorithm:
    //      Maintain a BITS character long buffer (so that 8 codes will
    // fit in it exactly).  Use the VAX insv instruction to insert each
    // code in turn.  When the buffer fills up empty it and start over.

    int cur_accum = 0;
    int cur_bits = 0;

    int masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
            0x001F, 0x003F, 0x007F, 0x00FF,
            0x01FF, 0x03FF, 0x07FF, 0x0FFF,
            0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };

    void output( int code, OutputStream outs ) throws IOException
    {
        cur_accum &= masks[cur_bits];

        if ( cur_bits > 0 )
            cur_accum |= ( code << cur_bits );
        else
            cur_accum = code;

        cur_bits += n_bits;

        while ( cur_bits >= 8 )
        {
            char_out( (byte) ( cur_accum & 0xff ), outs );
            cur_accum >>= 8;
            cur_bits -= 8;
        }

        // If the next entry is going to be too big for the code size,
        // then increase it, if possible.
       if ( free_ent > maxcode || clear_flg )
       {
            if ( clear_flg )
            {
                maxcode = MAXCODE(n_bits = g_init_bits);
                clear_flg = false;
            }
            else
            {
                ++n_bits;
                if ( n_bits == maxbits )
                    maxcode = maxmaxcode;
                else
                    maxcode = MAXCODE(n_bits);
            }
        }

        if ( code == EOFCode )
        {
            // At EOF, write the rest of the buffer.
            while ( cur_bits > 0 )
            {
                char_out( (byte) ( cur_accum & 0xff ), outs );
                cur_accum >>= 8;
                cur_bits -= 8;
            }

            flush_char( outs );
        }
    }

    // Clear out the hash table

    // table clear for block compress
    void cl_block( OutputStream outs ) throws IOException
    {
        cl_hash( hsize );
        free_ent = ClearCode + 2;
        clear_flg = true;

        output( ClearCode, outs );
    }

    // reset code table
    void cl_hash( int hsize )
    {
        for ( int i = 0; i < hsize; ++i )
            htab[i] = -1;
    }

    // GIF Specific routines

    // Number of characters so far in this 'packet'
    int a_count;

    // Set up the 'byte output' routine
    void char_init()
    {
        a_count = 0;
    }

    // Define the storage for the packet accumulator
    byte[] accum = new byte[256];

    // Add a character to the end of the current packet, and if it is 254
    // characters, flush the packet to disk.
    void char_out( byte c, OutputStream outs ) throws IOException
    {
        accum[a_count++] = c;
        if ( a_count >= 254 )
            flush_char( outs );
    }

        // Flush the packet to disk, and reset the accumulator
        void flush_char( OutputStream outs ) throws IOException
        {
            if ( a_count > 0 )
            {
                outs.write( a_count );
                outs.write( accum, 0, a_count );
                a_count = 0;
            }
        }

    }

    class GifEncoderHashitem
    {
        public int rgb;
        public int count;
        public int index;
        public boolean isTransparent;

        public GifEncoderHashitem(int rgb, int count, int index, boolean 
isTransparent) {
        this.rgb = rgb;
        this.count = count;
        this.index = index;
        this.isTransparent = isTransparent;
    }

} // end of GifEncoder
--
To unsubscribe, e-mail:   <mailto:velocity-user-unsubscribe@xxxxxxxxxxxxxxxxxx>
For additional commands, e-mail: <mailto:velocity-user-help@xxxxxxxxxxxxxxxxxx>