org.apache.batik.parser_1.6.0.v201011041432

16:40:53.659 INFO  jd.cli.Main - Decompiling org.apache.batik.parser_1.6.0.v201011041432.jar
package org.apache.batik.parser;

import java.awt.Shape;
import java.awt.geom.Point2D;
import java.io.IOException;
import java.io.Reader;
import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;

public class AWTPathProducer
  implements PathHandler, ShapeProducer
{
  protected ExtendedGeneralPath path;
  protected float currentX;
  protected float currentY;
  protected float xCenter;
  protected float yCenter;
  protected int windingRule;
  
  public static Shape createShape(Reader paramReader, int paramInt)
    throws IOException, ParseException
  {
    PathParser localPathParser = new PathParser();
    AWTPathProducer localAWTPathProducer = new AWTPathProducer();
    localAWTPathProducer.setWindingRule(paramInt);
    localPathParser.setPathHandler(localAWTPathProducer);
    localPathParser.parse(paramReader);
    return localAWTPathProducer.getShape();
  }
  
  public void setWindingRule(int paramInt)
  {
    windingRule = paramInt;
  }
  
  public int getWindingRule()
  {
    return windingRule;
  }
  
  public Shape getShape()
  {
    return path;
  }
  
  public void startPath()
    throws ParseException
  {
    currentX = 0.0F;
    currentY = 0.0F;
    xCenter = 0.0F;
    yCenter = 0.0F;
    path = new ExtendedGeneralPath(windingRule);
  }
  
  public void endPath()
    throws ParseException
  {}
  
  public void movetoRel(float paramFloat1, float paramFloat2)
    throws ParseException
  {
    path.moveTo(xCenter = currentX += paramFloat1, yCenter = currentY += paramFloat2);
  }
  
  public void movetoAbs(float paramFloat1, float paramFloat2)
    throws ParseException
  {
    path.moveTo(xCenter = currentX = paramFloat1, yCenter = currentY = paramFloat2);
  }
  
  public void closePath()
    throws ParseException
  {
    path.closePath();
    Point2D localPoint2D = path.getCurrentPoint();
    currentX = ((float)localPoint2D.getX());
    currentY = ((float)localPoint2D.getY());
  }
  
  public void linetoRel(float paramFloat1, float paramFloat2)
    throws ParseException
  {
    path.lineTo(xCenter = currentX += paramFloat1, yCenter = currentY += paramFloat2);
  }
  
  public void linetoAbs(float paramFloat1, float paramFloat2)
    throws ParseException
  {
    path.lineTo(xCenter = currentX = paramFloat1, yCenter = currentY = paramFloat2);
  }
  
  public void linetoHorizontalRel(float paramFloat)
    throws ParseException
  {
    path.lineTo(xCenter = currentX += paramFloat, yCenter = currentY);
  }
  
  public void linetoHorizontalAbs(float paramFloat)
    throws ParseException
  {
    path.lineTo(xCenter = currentX = paramFloat, yCenter = currentY);
  }
  
  public void linetoVerticalRel(float paramFloat)
    throws ParseException
  {
    path.lineTo(xCenter = currentX, yCenter = currentY += paramFloat);
  }
  
  public void linetoVerticalAbs(float paramFloat)
    throws ParseException
  {
    path.lineTo(xCenter = currentX, yCenter = currentY = paramFloat);
  }
  
  public void curvetoCubicRel(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
    throws ParseException
  {
    path.curveTo(currentX + paramFloat1, currentY + paramFloat2, xCenter = currentX + paramFloat3, yCenter = currentY + paramFloat4, currentX += paramFloat5, currentY += paramFloat6);
  }
  
  public void curvetoCubicAbs(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
    throws ParseException
  {
    path.curveTo(paramFloat1, paramFloat2, xCenter = paramFloat3, yCenter = paramFloat4, currentX = paramFloat5, currentY = paramFloat6);
  }
  
  public void curvetoCubicSmoothRel(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
    throws ParseException
  {
    path.curveTo(currentX * 2.0F - xCenter, currentY * 2.0F - yCenter, xCenter = currentX + paramFloat1, yCenter = currentY + paramFloat2, currentX += paramFloat3, currentY += paramFloat4);
  }
  
  public void curvetoCubicSmoothAbs(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
    throws ParseException
  {
    path.curveTo(currentX * 2.0F - xCenter, currentY * 2.0F - yCenter, xCenter = paramFloat1, yCenter = paramFloat2, currentX = paramFloat3, currentY = paramFloat4);
  }
  
  public void curvetoQuadraticRel(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
    throws ParseException
  {
    path.quadTo(xCenter = currentX + paramFloat1, yCenter = currentY + paramFloat2, currentX += paramFloat3, currentY += paramFloat4);
  }
  
  public void curvetoQuadraticAbs(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
    throws ParseException
  {
    path.quadTo(xCenter = paramFloat1, yCenter = paramFloat2, currentX = paramFloat3, currentY = paramFloat4);
  }
  
  public void curvetoQuadraticSmoothRel(float paramFloat1, float paramFloat2)
    throws ParseException
  {
    path.quadTo(xCenter = currentX * 2.0F - xCenter, yCenter = currentY * 2.0F - yCenter, currentX += paramFloat1, currentY += paramFloat2);
  }
  
  public void curvetoQuadraticSmoothAbs(float paramFloat1, float paramFloat2)
    throws ParseException
  {
    path.quadTo(xCenter = currentX * 2.0F - xCenter, yCenter = currentY * 2.0F - yCenter, currentX = paramFloat1, currentY = paramFloat2);
  }
  
  public void arcRel(float paramFloat1, float paramFloat2, float paramFloat3, boolean paramBoolean1, boolean paramBoolean2, float paramFloat4, float paramFloat5)
    throws ParseException
  {
    path.arcTo(paramFloat1, paramFloat2, paramFloat3, paramBoolean1, paramBoolean2, xCenter = currentX += paramFloat4, yCenter = currentY += paramFloat5);
  }
  
  public void arcAbs(float paramFloat1, float paramFloat2, float paramFloat3, boolean paramBoolean1, boolean paramBoolean2, float paramFloat4, float paramFloat5)
    throws ParseException
  {
    path.arcTo(paramFloat1, paramFloat2, paramFloat3, paramBoolean1, paramBoolean2, xCenter = currentX = paramFloat4, yCenter = currentY = paramFloat5);
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.AWTPathProducer
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

import java.awt.Shape;
import java.awt.geom.GeneralPath;
import java.io.IOException;
import java.io.Reader;

public class AWTPolygonProducer
  extends AWTPolylineProducer
{
  public static Shape createShape(Reader paramReader, int paramInt)
    throws IOException, ParseException
  {
    PointsParser localPointsParser = new PointsParser();
    AWTPolygonProducer localAWTPolygonProducer = new AWTPolygonProducer();
    localAWTPolygonProducer.setWindingRule(paramInt);
    localPointsParser.setPointsHandler(localAWTPolygonProducer);
    localPointsParser.parse(paramReader);
    return localAWTPolygonProducer.getShape();
  }
  
  public void endPoints()
    throws ParseException
  {
    path.closePath();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.AWTPolygonProducer
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

import java.awt.Shape;
import java.awt.geom.GeneralPath;
import java.io.IOException;
import java.io.Reader;

public class AWTPolylineProducer
  implements PointsHandler, ShapeProducer
{
  protected GeneralPath path;
  protected boolean newPath;
  protected int windingRule;
  
  public static Shape createShape(Reader paramReader, int paramInt)
    throws IOException, ParseException
  {
    PointsParser localPointsParser = new PointsParser();
    AWTPolylineProducer localAWTPolylineProducer = new AWTPolylineProducer();
    localAWTPolylineProducer.setWindingRule(paramInt);
    localPointsParser.setPointsHandler(localAWTPolylineProducer);
    localPointsParser.parse(paramReader);
    return localAWTPolylineProducer.getShape();
  }
  
  public void setWindingRule(int paramInt)
  {
    windingRule = paramInt;
  }
  
  public int getWindingRule()
  {
    return windingRule;
  }
  
  public Shape getShape()
  {
    return path;
  }
  
  public void startPoints()
    throws ParseException
  {
    path = new GeneralPath(windingRule);
    newPath = true;
  }
  
  public void point(float paramFloat1, float paramFloat2)
    throws ParseException
  {
    if (newPath)
    {
      newPath = false;
      path.moveTo(paramFloat1, paramFloat2);
    }
    else
    {
      path.lineTo(paramFloat1, paramFloat2);
    }
  }
  
  public void endPoints()
    throws ParseException
  {}
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.AWTPolylineProducer
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

import java.awt.geom.AffineTransform;
import java.io.Reader;

public class AWTTransformProducer
  implements TransformListHandler
{
  protected AffineTransform affineTransform;
  
  public static AffineTransform createAffineTransform(Reader paramReader)
    throws ParseException
  {
    TransformListParser localTransformListParser = new TransformListParser();
    AWTTransformProducer localAWTTransformProducer = new AWTTransformProducer();
    localTransformListParser.setTransformListHandler(localAWTTransformProducer);
    localTransformListParser.parse(paramReader);
    return localAWTTransformProducer.getAffineTransform();
  }
  
  public static AffineTransform createAffineTransform(String paramString)
    throws ParseException
  {
    TransformListParser localTransformListParser = new TransformListParser();
    AWTTransformProducer localAWTTransformProducer = new AWTTransformProducer();
    localTransformListParser.setTransformListHandler(localAWTTransformProducer);
    localTransformListParser.parse(paramString);
    return localAWTTransformProducer.getAffineTransform();
  }
  
  public AffineTransform getAffineTransform()
  {
    return affineTransform;
  }
  
  public void startTransformList()
    throws ParseException
  {
    affineTransform = new AffineTransform();
  }
  
  public void matrix(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
    throws ParseException
  {
    affineTransform.concatenate(new AffineTransform(paramFloat1, paramFloat2, paramFloat3, paramFloat4, paramFloat5, paramFloat6));
  }
  
  public void rotate(float paramFloat)
    throws ParseException
  {
    affineTransform.concatenate(AffineTransform.getRotateInstance(3.141592653589793D * paramFloat / 180.0D));
  }
  
  public void rotate(float paramFloat1, float paramFloat2, float paramFloat3)
    throws ParseException
  {
    AffineTransform localAffineTransform = AffineTransform.getRotateInstance(3.141592653589793D * paramFloat1 / 180.0D, paramFloat2, paramFloat3);
    affineTransform.concatenate(localAffineTransform);
  }
  
  public void translate(float paramFloat)
    throws ParseException
  {
    AffineTransform localAffineTransform = AffineTransform.getTranslateInstance(paramFloat, 0.0D);
    affineTransform.concatenate(localAffineTransform);
  }
  
  public void translate(float paramFloat1, float paramFloat2)
    throws ParseException
  {
    AffineTransform localAffineTransform = AffineTransform.getTranslateInstance(paramFloat1, paramFloat2);
    affineTransform.concatenate(localAffineTransform);
  }
  
  public void scale(float paramFloat)
    throws ParseException
  {
    affineTransform.concatenate(AffineTransform.getScaleInstance(paramFloat, paramFloat));
  }
  
  public void scale(float paramFloat1, float paramFloat2)
    throws ParseException
  {
    affineTransform.concatenate(AffineTransform.getScaleInstance(paramFloat1, paramFloat2));
  }
  
  public void skewX(float paramFloat)
    throws ParseException
  {
    affineTransform.concatenate(AffineTransform.getShearInstance(Math.tan(3.141592653589793D * paramFloat / 180.0D), 0.0D));
  }
  
  public void skewY(float paramFloat)
    throws ParseException
  {
    affineTransform.concatenate(AffineTransform.getShearInstance(0.0D, Math.tan(3.141592653589793D * paramFloat / 180.0D)));
  }
  
  public void endTransformList()
    throws ParseException
  {}
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.AWTTransformProducer
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.Locale;
import java.util.MissingResourceException;
import org.apache.batik.i18n.LocalizableSupport;
import org.apache.batik.util.io.NormalizingReader;
import org.apache.batik.util.io.StreamNormalizingReader;
import org.apache.batik.util.io.StringNormalizingReader;

public abstract class AbstractParser
  implements Parser
{
  public static final String BUNDLE_CLASSNAME = "org.apache.batik.parser.resources.Messages";
  protected ErrorHandler errorHandler = new DefaultErrorHandler();
  protected LocalizableSupport localizableSupport = new LocalizableSupport("org.apache.batik.parser.resources.Messages", AbstractParser.class.getClassLoader());
  protected NormalizingReader reader;
  protected int current;
  
  public int getCurrent()
  {
    return current;
  }
  
  public void setLocale(Locale paramLocale)
  {
    localizableSupport.setLocale(paramLocale);
  }
  
  public Locale getLocale()
  {
    return localizableSupport.getLocale();
  }
  
  public String formatMessage(String paramString, Object[] paramArrayOfObject)
    throws MissingResourceException
  {
    return localizableSupport.formatMessage(paramString, paramArrayOfObject);
  }
  
  public void setErrorHandler(ErrorHandler paramErrorHandler)
  {
    errorHandler = paramErrorHandler;
  }
  
  public void parse(Reader paramReader)
    throws ParseException
  {
    try
    {
      reader = new StreamNormalizingReader(paramReader);
      doParse();
    }
    catch (IOException localIOException)
    {
      errorHandler.error(new ParseException(createErrorMessage("io.exception", null), localIOException));
    }
  }
  
  public void parse(InputStream paramInputStream, String paramString)
    throws ParseException
  {
    try
    {
      reader = new StreamNormalizingReader(paramInputStream, paramString);
      doParse();
    }
    catch (IOException localIOException)
    {
      errorHandler.error(new ParseException(createErrorMessage("io.exception", null), localIOException));
    }
  }
  
  public void parse(String paramString)
    throws ParseException
  {
    try
    {
      reader = new StringNormalizingReader(paramString);
      doParse();
    }
    catch (IOException localIOException)
    {
      errorHandler.error(new ParseException(createErrorMessage("io.exception", null), localIOException));
    }
  }
  
  protected abstract void doParse()
    throws ParseException, IOException;
  
  protected void reportError(String paramString, Object[] paramArrayOfObject)
    throws ParseException
  {
    errorHandler.error(new ParseException(createErrorMessage(paramString, paramArrayOfObject), reader.getLine(), reader.getColumn()));
  }
  
  protected String createErrorMessage(String paramString, Object[] paramArrayOfObject)
  {
    try
    {
      return formatMessage(paramString, paramArrayOfObject);
    }
    catch (MissingResourceException localMissingResourceException) {}
    return paramString;
  }
  
  protected String getBundleClassName()
  {
    return "org.apache.batik.parser.resources.Messages";
  }
  
  protected void skipSpaces()
    throws IOException
  {
    for (;;)
    {
      switch (current)
      {
      default: 
        return;
      }
      current = reader.read();
    }
  }
  
  protected void skipCommaSpaces()
    throws IOException
  {
    for (;;)
    {
      switch (current)
      {
      default: 
        break;
      case 9: 
      case 10: 
      case 13: 
      case 32: 
        current = reader.read();
      }
    }
    if (current == 44) {
      for (;;)
      {
        switch (current = reader.read())
        {
        default: 
          return;
        }
      }
    }
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.AbstractParser
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public abstract interface AngleHandler
{
  public abstract void startAngle()
    throws ParseException;
  
  public abstract void angleValue(float paramFloat)
    throws ParseException;
  
  public abstract void deg()
    throws ParseException;
  
  public abstract void grad()
    throws ParseException;
  
  public abstract void rad()
    throws ParseException;
  
  public abstract void endAngle()
    throws ParseException;
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.AngleHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

import java.io.IOException;
import java.io.Reader;

public class AngleParser
  extends NumberParser
{
  protected AngleHandler angleHandler = DefaultAngleHandler.INSTANCE;
  
  public void setAngleHandler(AngleHandler paramAngleHandler)
  {
    angleHandler = paramAngleHandler;
  }
  
  public AngleHandler getAngleHandler()
  {
    return angleHandler;
  }
  
  protected void doParse()
    throws ParseException, IOException
  {
    angleHandler.startAngle();
    current = reader.read();
    skipSpaces();
    try
    {
      float f = parseFloat();
      angleHandler.angleValue(f);
      if (current != -1) {
        switch (current)
        {
        case 9: 
        case 10: 
        case 13: 
        case 32: 
          break;
        default: 
          switch (current)
          {
          case 100: 
            current = reader.read();
            if (current != 101)
            {
              reportError("character.expected", new Object[] { new Character('e'), new Integer(current) });
            }
            else
            {
              current = reader.read();
              if (current != 103)
              {
                reportError("character.expected", new Object[] { new Character('g'), new Integer(current) });
              }
              else
              {
                angleHandler.deg();
                current = reader.read();
              }
            }
            break;
          case 103: 
            current = reader.read();
            if (current != 114)
            {
              reportError("character.expected", new Object[] { new Character('r'), new Integer(current) });
            }
            else
            {
              current = reader.read();
              if (current != 97)
              {
                reportError("character.expected", new Object[] { new Character('a'), new Integer(current) });
              }
              else
              {
                current = reader.read();
                if (current != 100)
                {
                  reportError("character.expected", new Object[] { new Character('d'), new Integer(current) });
                }
                else
                {
                  angleHandler.grad();
                  current = reader.read();
                }
              }
            }
            break;
          case 114: 
            current = reader.read();
            if (current != 97)
            {
              reportError("character.expected", new Object[] { new Character('a'), new Integer(current) });
            }
            else
            {
              current = reader.read();
              if (current != 100)
              {
                reportError("character.expected", new Object[] { new Character('d'), new Integer(current) });
              }
              else
              {
                angleHandler.rad();
                current = reader.read();
              }
            }
            break;
          default: 
            reportError("character.unexpected", new Object[] { new Integer(current) });
          }
          break;
        }
      }
      skipSpaces();
      if (current != -1) {
        reportError("end.of.stream.expected", new Object[] { new Integer(current) });
      }
    }
    catch (NumberFormatException localNumberFormatException)
    {
      reportError("character.unexpected", new Object[] { new Integer(current) });
    }
    angleHandler.endAngle();
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.AngleParser
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public abstract interface ClockHandler
{
  public abstract void startClock()
    throws ParseException;
  
  public abstract void intValue(int paramInt)
    throws ParseException;
  
  public abstract void colon()
    throws ParseException;
  
  public abstract void dot()
    throws ParseException;
  
  public abstract void h()
    throws ParseException;
  
  public abstract void min()
    throws ParseException;
  
  public abstract void s()
    throws ParseException;
  
  public abstract void ms()
    throws ParseException;
  
  public abstract void endClock()
    throws ParseException;
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.ClockHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public abstract interface ClockParser
  extends Parser
{
  public abstract void setClockHandler(ClockHandler paramClockHandler);
  
  public abstract ClockHandler getClockHandler();
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.ClockParser
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public class DefaultAngleHandler
  implements AngleHandler
{
  public static final AngleHandler INSTANCE = new DefaultAngleHandler();
  
  public void startAngle()
    throws ParseException
  {}
  
  public void angleValue(float paramFloat)
    throws ParseException
  {}
  
  public void deg()
    throws ParseException
  {}
  
  public void grad()
    throws ParseException
  {}
  
  public void rad()
    throws ParseException
  {}
  
  public void endAngle()
    throws ParseException
  {}
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.DefaultAngleHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public class DefaultErrorHandler
  implements ErrorHandler
{
  public void error(ParseException paramParseException)
    throws ParseException
  {
    throw paramParseException;
  }
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.DefaultErrorHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public class DefaultFragmentIdentifierHandler
  extends DefaultPreserveAspectRatioHandler
  implements FragmentIdentifierHandler
{
  public static final FragmentIdentifierHandler INSTANCE = new DefaultFragmentIdentifierHandler();
  
  public void startFragmentIdentifier()
    throws ParseException
  {}
  
  public void idReference(String paramString)
    throws ParseException
  {}
  
  public void viewBox(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
    throws ParseException
  {}
  
  public void startViewTarget()
    throws ParseException
  {}
  
  public void viewTarget(String paramString)
    throws ParseException
  {}
  
  public void endViewTarget()
    throws ParseException
  {}
  
  public void startTransformList()
    throws ParseException
  {}
  
  public void matrix(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
    throws ParseException
  {}
  
  public void rotate(float paramFloat)
    throws ParseException
  {}
  
  public void rotate(float paramFloat1, float paramFloat2, float paramFloat3)
    throws ParseException
  {}
  
  public void translate(float paramFloat)
    throws ParseException
  {}
  
  public void translate(float paramFloat1, float paramFloat2)
    throws ParseException
  {}
  
  public void scale(float paramFloat)
    throws ParseException
  {}
  
  public void scale(float paramFloat1, float paramFloat2)
    throws ParseException
  {}
  
  public void skewX(float paramFloat)
    throws ParseException
  {}
  
  public void skewY(float paramFloat)
    throws ParseException
  {}
  
  public void endTransformList()
    throws ParseException
  {}
  
  public void zoomAndPan(boolean paramBoolean) {}
  
  public void endFragmentIdentifier()
    throws ParseException
  {}
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.DefaultFragmentIdentifierHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public class DefaultLengthHandler
  implements LengthHandler
{
  public static final LengthHandler INSTANCE = new DefaultLengthHandler();
  
  public void startLength()
    throws ParseException
  {}
  
  public void lengthValue(float paramFloat)
    throws ParseException
  {}
  
  public void em()
    throws ParseException
  {}
  
  public void ex()
    throws ParseException
  {}
  
  public void in()
    throws ParseException
  {}
  
  public void cm()
    throws ParseException
  {}
  
  public void mm()
    throws ParseException
  {}
  
  public void pc()
    throws ParseException
  {}
  
  public void pt()
    throws ParseException
  {}
  
  public void px()
    throws ParseException
  {}
  
  public void percentage()
    throws ParseException
  {}
  
  public void endLength()
    throws ParseException
  {}
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.DefaultLengthHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public class DefaultLengthListHandler
  extends DefaultLengthHandler
  implements LengthListHandler
{
  public static final LengthListHandler INSTANCE = new DefaultLengthListHandler();
  
  public void startLengthList()
    throws ParseException
  {}
  
  public void endLengthList()
    throws ParseException
  {}
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.DefaultLengthListHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public class DefaultNumberListHandler
  implements NumberListHandler
{
  public static final NumberListHandler INSTANCE = new DefaultNumberListHandler();
  
  public void startNumberList()
    throws ParseException
  {}
  
  public void endNumberList()
    throws ParseException
  {}
  
  public void startNumber()
    throws ParseException
  {}
  
  public void numberValue(float paramFloat)
    throws ParseException
  {}
  
  public void endNumber()
    throws ParseException
  {}
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.DefaultNumberListHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public class DefaultPathHandler
  implements PathHandler
{
  public static final PathHandler INSTANCE = new DefaultPathHandler();
  
  public void startPath()
    throws ParseException
  {}
  
  public void endPath()
    throws ParseException
  {}
  
  public void movetoRel(float paramFloat1, float paramFloat2)
    throws ParseException
  {}
  
  public void movetoAbs(float paramFloat1, float paramFloat2)
    throws ParseException
  {}
  
  public void closePath()
    throws ParseException
  {}
  
  public void linetoRel(float paramFloat1, float paramFloat2)
    throws ParseException
  {}
  
  public void linetoAbs(float paramFloat1, float paramFloat2)
    throws ParseException
  {}
  
  public void linetoHorizontalRel(float paramFloat)
    throws ParseException
  {}
  
  public void linetoHorizontalAbs(float paramFloat)
    throws ParseException
  {}
  
  public void linetoVerticalRel(float paramFloat)
    throws ParseException
  {}
  
  public void linetoVerticalAbs(float paramFloat)
    throws ParseException
  {}
  
  public void curvetoCubicRel(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
    throws ParseException
  {}
  
  public void curvetoCubicAbs(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
    throws ParseException
  {}
  
  public void curvetoCubicSmoothRel(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
    throws ParseException
  {}
  
  public void curvetoCubicSmoothAbs(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
    throws ParseException
  {}
  
  public void curvetoQuadraticRel(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
    throws ParseException
  {}
  
  public void curvetoQuadraticAbs(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
    throws ParseException
  {}
  
  public void curvetoQuadraticSmoothRel(float paramFloat1, float paramFloat2)
    throws ParseException
  {}
  
  public void curvetoQuadraticSmoothAbs(float paramFloat1, float paramFloat2)
    throws ParseException
  {}
  
  public void arcRel(float paramFloat1, float paramFloat2, float paramFloat3, boolean paramBoolean1, boolean paramBoolean2, float paramFloat4, float paramFloat5)
    throws ParseException
  {}
  
  public void arcAbs(float paramFloat1, float paramFloat2, float paramFloat3, boolean paramBoolean1, boolean paramBoolean2, float paramFloat4, float paramFloat5)
    throws ParseException
  {}
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.DefaultPathHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public class DefaultPointsHandler
  implements PointsHandler
{
  public static final DefaultPointsHandler INSTANCE = new DefaultPointsHandler();
  
  public void startPoints()
    throws ParseException
  {}
  
  public void point(float paramFloat1, float paramFloat2)
    throws ParseException
  {}
  
  public void endPoints()
    throws ParseException
  {}
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.DefaultPointsHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public class DefaultPreserveAspectRatioHandler
  implements PreserveAspectRatioHandler
{
  public static final PreserveAspectRatioHandler INSTANCE = new DefaultPreserveAspectRatioHandler();
  
  public void startPreserveAspectRatio()
    throws ParseException
  {}
  
  public void none()
    throws ParseException
  {}
  
  public void xMaxYMax()
    throws ParseException
  {}
  
  public void xMaxYMid()
    throws ParseException
  {}
  
  public void xMaxYMin()
    throws ParseException
  {}
  
  public void xMidYMax()
    throws ParseException
  {}
  
  public void xMidYMid()
    throws ParseException
  {}
  
  public void xMidYMin()
    throws ParseException
  {}
  
  public void xMinYMax()
    throws ParseException
  {}
  
  public void xMinYMid()
    throws ParseException
  {}
  
  public void xMinYMin()
    throws ParseException
  {}
  
  public void meet()
    throws ParseException
  {}
  
  public void slice()
    throws ParseException
  {}
  
  public void endPreserveAspectRatio()
    throws ParseException
  {}
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.DefaultPreserveAspectRatioHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public class DefaultTransformListHandler
  implements TransformListHandler
{
  public static final TransformListHandler INSTANCE = new DefaultTransformListHandler();
  
  public void startTransformList()
    throws ParseException
  {}
  
  public void matrix(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
    throws ParseException
  {}
  
  public void rotate(float paramFloat)
    throws ParseException
  {}
  
  public void rotate(float paramFloat1, float paramFloat2, float paramFloat3)
    throws ParseException
  {}
  
  public void translate(float paramFloat)
    throws ParseException
  {}
  
  public void translate(float paramFloat1, float paramFloat2)
    throws ParseException
  {}
  
  public void scale(float paramFloat)
    throws ParseException
  {}
  
  public void scale(float paramFloat1, float paramFloat2)
    throws ParseException
  {}
  
  public void skewX(float paramFloat)
    throws ParseException
  {}
  
  public void skewY(float paramFloat)
    throws ParseException
  {}
  
  public void endTransformList()
    throws ParseException
  {}
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.DefaultTransformListHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public abstract interface ErrorHandler
{
  public abstract void error(ParseException paramParseException)
    throws ParseException;
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.ErrorHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

public abstract interface FragmentIdentifierHandler
  extends PreserveAspectRatioHandler, TransformListHandler
{
  public abstract void startFragmentIdentifier()
    throws ParseException;
  
  public abstract void idReference(String paramString)
    throws ParseException;
  
  public abstract void viewBox(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
    throws ParseException;
  
  public abstract void startViewTarget()
    throws ParseException;
  
  public abstract void viewTarget(String paramString)
    throws ParseException;
  
  public abstract void endViewTarget()
    throws ParseException;
  
  public abstract void zoomAndPan(boolean paramBoolean);
  
  public abstract void endFragmentIdentifier()
    throws ParseException;
}

/* Location:
 * Qualified Name:     org.apache.batik.parser.FragmentIdentifierHandler
 * Java Class Version: 1.1 (45.3)
 * JD-Core Version:    0.7.1
 */
package org.apache.batik.parser;

import java.io.IOException;
import java.io.Reader;
import org.apache.batik.xml.XMLUtilities;

public class FragmentIdentifierParser
  extends NumberParser
{
  protected char[] buffer = new char[16];
  protected int bufferSize;
  protected FragmentIdentifierHandler fragmentIdentifierHandler = DefaultFragmentIdentifierHandler.INSTANCE;
  
  public void setFragmentIdentifierHandler(FragmentIdentifierHandler paramFragmentIdentifierHandler)
  {
    fragmentIdentifierHandler = paramFragmentIdentifierHandler;
  }
  
  public FragmentIdentifierHandler getFragmentIdentifierHandler()
  {
    return fragmentIdentifierHandler;
  }
  
  protected void doParse()
    throws ParseException, IOException
  {
    bufferSize = 0;
    current = reader.read();
    fragmentIdentifierHandler.startFragmentIdentifier();
    String str = null;
    switch (current)
    {
    case 120: 
      bufferize();
      current = reader.read();
      if (current != 112)
      {
        parseIdentifier();
      }
      else
      {
        bufferize();
        current = reader.read();
        if (current != 111)
        {
          parseIdentifier();
        }
        else
        {
          bufferize();
          current = reader.read();
          if (current != 105)
          {
            parseIdentifier();
          }
          else
          {
            bufferize();
            current = reader.read();
            if (current != 110)
            {
              parseIdentifier();
            }
            else
            {
              bufferize();
              current = reader.read();
              if (current != 116)
              {
                parseIdentifier();
              }
              else
              {
                bufferize();
                current = reader.read();
                if (current != 101)
                {
                  parseIdentifier();
                }
                else
                {
                  bufferize();
                  current = reader.read();
                  if (current != 114)
                  {
                    parseIdentifier();
                  }
                  else
                  {
                    bufferize();
                    current = reader.read();
                    if (current != 40)
                    {
                      parseIdentifier();
                    }
                    else
                    {
                      bufferSize = 0;
                      current = reader.read();
                      if (current != 105)
                      {
                        reportError("character.expected", new Object[] { new Character('i'), new Integer(current) });
                      }
                      else
                      {
                        current = reader.read();
                        if (current != 100)
                        {
                          reportError("character.expected", new Object[] { new Character('d'), new Integer(current) });
                        }
                        else
                        {
                          current = reader.read();
                          if (current != 40)
                          {
                            reportError("character.expected", new Object[] { new Character('('), new Integer(current) });
                          }
                          else
                          {
                            current = reader.read();
                            if ((current != 34) && (current != 39))
                            {
                              reportError("character.expected", new Object[] { new Character('\''), new Integer(current) });
                            }
                            else
                            {
                              int i = (char)current;
                              current = reader.read();
                              parseIdentifier();
                              str = getBufferContent();
                              bufferSize = 0;
                              fragmentIdentifierHandler.idReference(str);
                              if (current != i)
                              {
                                reportError("character.expected", new Object[] { new Character(i), new Integer(current) });
                              }
                              else
                              {
                                current = reader.read();
                                if (current != 41)
                                {
                                  reportError("character.expected", new Object[] { new Character(')'), new Integer(current) });
                                }
                                else
                                {
                                  current = reader.read();
                                  if (current != 41) {
                                    reportError("character.expected", new Object[] { new Character(')'), new Integer(current) });
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
      break;
    case 115: 
      bufferize();
      current = reader.read();
      if (current != 118)
      {
        parseIdentifier();
      }
      else
      {
        bufferize();
        current = reader.read();
        if (current != 103)
        {
          parseIdentifier();
        }
        else
        {
          bufferize();
          current = reader.read();
          if (current != 86)
          {
            parseIdentifier();
          }
          else
          {
            bufferize();
            current = reader.read();
            if (current !
1 2 3 4

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2017. Infinite Loop Ltd