S283 Planetary Science &n…he Search for Life DVD 2/DVD-ROM.iso/install/jre1_3/lib/rt.jar/sun/java2d/SunGraphics2D.class

Java Class File | 1979-12-31 | 26.8 KB | 1,638 lines

package sun.java2d;

import java.awt.AWTPermission;
import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.Paint;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.font.TextLayout;
import java.awt.geom.AffineTransform;
import java.awt.geom.Area;
import java.awt.geom.GeneralPath;
import java.awt.geom.NoninvertibleTransformException;
import java.awt.geom.PathIterator;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RectangularShape;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.awt.image.BufferedImageOp;
import java.awt.image.ColorModel;
import java.awt.image.DirectColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.IndexColorModel;
import java.awt.image.Raster;
import java.awt.image.RenderedImage;
import java.awt.image.WritableRaster;
import java.awt.image.renderable.RenderContext;
import java.awt.image.renderable.RenderableImage;
import java.security.Permission;
import java.text.AttributedCharacterIterator;
import java.util.Hashtable;
import java.util.Map;
import sun.awt.ConstrainableGraphics;
import sun.awt.SunHints;
import sun.awt.SunHints.Value;
import sun.awt.font.FontDesignMetrics;
import sun.awt.font.ShapingException;
import sun.awt.image.BytePackedRaster;
import sun.java2d.loops.DrawString;
import sun.java2d.loops.ImageData;
import sun.java2d.loops.RasterOutputManager;
import sun.java2d.loops.XORComposite;
import sun.java2d.pipe.CompositePipe;
import sun.java2d.pipe.PixelDrawPipe;
import sun.java2d.pipe.PixelFillPipe;
import sun.java2d.pipe.Region;
import sun.java2d.pipe.RegionIterator;
import sun.java2d.pipe.ShapeDrawPipe;
import sun.java2d.pipe.ShapeSpanIterator;
import sun.java2d.pipe.TextPipe;
import sun.java2d.pipe.ValidatePipe;

public abstract class SunGraphics2D extends Graphics2D implements ConstrainableGraphics, Cloneable {
   public static final ColorModel XRGBModel = new DirectColorModel(24, 16711680, 65280, 255);
   public static final int LOCK_OK = 1;
   public static final int UNLOCK_OK = 2;
   public static final int LOCK_FORMAT_PROBLEM = 3;
   public static final int LOCK_GEOMETRY_PROBLEM = 4;
   public static final int LOCK_DATA_STRUCT_PROBLEM = 5;
   public static final int LOCK_NOT_LOCKED = 6;
   public static final int LOCK_ALREADY_LOCKED = 7;
   public static final int LOCK_FASTEST_UNAVAILABLE = 8;
   public static final int PAINT_TILE = 2;
   public static final int PAINT_SINGLECOLOR = 1;
   public static final int PAINT_SOLIDCOLOR = 0;
   public static final int COMP_CUSTOM = 3;
   public static final int COMP_XOR = 2;
   public static final int COMP_ALPHA = 1;
   public static final int COMP_ISCOPY = 0;
   public static final int STROKE_CUSTOM = 1;
   public static final int STROKE_BASIC = 0;
   public static final int TRANSFORM_GENERIC = 2;
   public static final int TRANSFORM_TRANSLATEONLY = 1;
   public static final int TRANSFORM_ISIDENT = 0;
   public static final int CLIP_SHAPE = 2;
   public static final int CLIP_RECTANGULAR = 1;
   public static final int CLIP_DEVICE = 0;
   public static final int XOR_MODE = 1;
   public static final int PAINT_MODE = 0;
   public int paintState;
   public int compositeState;
   public int strokeState;
   public int transformState;
   public int clipState;
   public int modeState;
   protected static final Color nullXORColor = new Color(0, 0, 0, 0);
   public Color foregroundColor;
   public Color backgroundColor;
   public Color xorColor;
   public AffineTransform transform;
   public int transX;
   public int transY;
   public boolean complexTransform;
   protected static final Stroke defaultStroke = new BasicStroke();
   protected static final Composite defaultComposite;
   public Stroke stroke;
   public Composite composite;
   public Paint paint;
   public int renderHint;
   public int antialiasHint;
   private int textAntialiasHint;
   private int fractionalMetricsHint;
   private int interpolationHint;
   public int strokeHint;
   protected Font font;
   protected FontMetrics fontMetrics;
   public RenderingHints hints;
   public Rectangle constrainClip;
   public int constrainX;
   public int constrainY;
   public Region clipRegion;
   public Shape usrClip;
   protected Rectangle devClip;
   protected Rectangle compBounds;
   protected static ValidatePipe invalidpipe;
   public PixelDrawPipe drawpipe;
   public PixelFillPipe fillpipe;
   public ShapeDrawPipe shapepipe;
   public TextPipe textpipe;
   public CompositePipe alphapipe;
   private Object copyAreaStateCache;
   private Object rpics;
   public boolean simpleText = true;
   private Object dscc;
   private Object dvcc;
   private Object dccc;
   private Object dbcc;
   public DrawString drawStringClass = null;
   public static CachedMetrics[] metricscache;
   static Permission compPermission;
   static final int NON_RECTILINEAR_TRANSFORM_MASK = 48;

   protected SunGraphics2D() {
      this.foregroundColor = Color.white;
      this.backgroundColor = Color.black;
      this.xorColor = nullXORColor;
      this.transform = new AffineTransform();
      this.stroke = defaultStroke;
      this.composite = defaultComposite;
      this.paint = this.foregroundColor;
      this.renderHint = 0;
      this.antialiasHint = 1;
      this.textAntialiasHint = 0;
      this.fractionalMetricsHint = 1;
      this.interpolationHint = -1;
      this.strokeHint = 0;
      this.invalidatePipe();
   }

   protected Object clone() {
      try {
         SunGraphics2D var1 = (SunGraphics2D)super.clone();
         var1.transform = new AffineTransform(this.transform);
         if (this.hints != null) {
            var1.hints = (RenderingHints)this.hints.clone();
         }

         var1.invalidatePipe();
         return var1;
      } catch (CloneNotSupportedException var2) {
         return null;
      }
   }

   public Graphics create() {
      return (Graphics)this.clone();
   }

   public void setDevClip(int var1, int var2, int var3, int var4) {
      Rectangle var5 = new Rectangle(var1, var2, var3, var4);
      Rectangle var6 = this.constrainClip;
      if (var6 == null) {
         this.devClip = var5;
      } else {
         this.devClip = var5.intersection(var6);
      }

      this.invalidateClip();
   }

   public void constrain(int var1, int var2, int var3, int var4) {
      Rectangle var5 = this.constrainClip;
      if (var5 == null || (var1 | var2) != 0 || var5.x < this.constrainX || var5.y < this.constrainY || this.constrainX + var3 < var5.x + var5.width || this.constrainY + var4 < var5.y + var5.height) {
         if ((var1 | var2) != 0) {
            this.constrainX += var1;
            this.constrainY += var2;
            if (this.transformState == 2) {
               AffineTransform var6 = AffineTransform.getTranslateInstance((double)var1, (double)var2);
               this.transform.preConcatenate(var6);
               this.invalidateTransform();
            } else {
               this.translate(var1, var2);
            }
         }

         Rectangle var7 = new Rectangle(this.constrainX, this.constrainY, var3, var4);
         if (var5 != null) {
            if (var7.contains(var5)) {
               return;
            }

            var7 = var7.intersection(var5);
         }

         this.constrainClip = var7;
         if (!var7.contains(this.devClip)) {
            this.devClip = this.devClip.intersection(var7);
            this.invalidateClip();
         }

      }
   }

   protected void invalidatePipe() {
      this.drawpipe = invalidpipe;
      this.fillpipe = invalidpipe;
      this.shapepipe = invalidpipe;
      this.textpipe = invalidpipe;
      this.alphapipe = null;
      this.dscc = null;
      this.dbcc = null;
      this.dccc = null;
      this.dvcc = null;
   }

   public void validatePipe() {
      this.getOutputManager().validatePipe(this);
   }

   Shape intersectShapes(Shape var1, Shape var2, boolean var3, boolean var4) {
      if (var1 instanceof Rectangle && var2 instanceof Rectangle) {
         return ((Rectangle)var1).intersection((Rectangle)var2);
      } else if (var1 instanceof Rectangle2D) {
         return this.intersectRectShape((Rectangle2D)var1, var2, var3, var4);
      } else {
         return var2 instanceof Rectangle2D ? this.intersectRectShape((Rectangle2D)var2, var1, var4, var3) : this.intersectByArea(var1, var2, var3, var4);
      }
   }

   Shape intersectRectShape(Rectangle2D var1, Shape var2, boolean var3, boolean var4) {
      if (var2 instanceof Rectangle2D) {
         Rectangle2D var5 = (Rectangle2D)var2;
         Object var6;
         if (!var3) {
            var6 = var1;
         } else if (!var4) {
            var6 = var5;
         } else {
            var6 = new Rectangle2D.Float();
         }

         double var7 = Math.max(((RectangularShape)var1).getX(), ((RectangularShape)var5).getX());
         double var9 = Math.min(((RectangularShape)var1).getX() + ((RectangularShape)var1).getWidth(), ((RectangularShape)var5).getX() + ((RectangularShape)var5).getWidth());
         double var11 = Math.max(((RectangularShape)var1).getY(), ((RectangularShape)var5).getY());
         double var13 = Math.min(((RectangularShape)var1).getY() + ((RectangularShape)var1).getHeight(), ((RectangularShape)var5).getY() + ((RectangularShape)var5).getHeight());
         if (!(var9 - var7 < (double)0.0F) && !(var13 - var11 < (double)0.0F)) {
            ((RectangularShape)var6).setFrameFromDiagonal(var7, var11, var9, var13);
         } else {
            ((RectangularShape)var6).setFrameFromDiagonal((double)0.0F, (double)0.0F, (double)0.0F, (double)0.0F);
         }

         return (Shape)var6;
      } else if (((RectangularShape)var1).contains(var2.getBounds2D())) {
         if (var4) {
            var2 = cloneShape(var2);
         }

         return var2;
      } else {
         return this.intersectByArea(var1, var2, var3, var4);
      }
   }

   protected static Shape cloneShape(Shape var0) {
      return new GeneralPath(var0);
   }

   Shape intersectByArea(Shape var1, Shape var2, boolean var3, boolean var4) {
      Area var5;
      if (!var3 && var1 instanceof Area) {
         var5 = (Area)var1;
      } else if (!var4 && var2 instanceof Area) {
         var5 = (Area)var2;
         var2 = var1;
      } else {
         var5 = new Area(var1);
      }

      Area var6;
      if (var2 instanceof Area) {
         var6 = (Area)var2;
      } else {
         var6 = new Area(var2);
      }

      var5.intersect(var6);
      return (Shape)(var5.isRectangular() ? var5.getBounds() : var5);
   }

   public Rectangle getCompBounds() {
      Rectangle var1;
      if ((var1 = this.compBounds) == null) {
         switch (this.clipState) {
            case 0:
               var1 = this.devClip;
               break;
            case 1:
               if (this.usrClip instanceof Rectangle) {
                  var1 = this.devClip.intersection((Rectangle)this.usrClip);
               } else {
                  var1 = this.devClip.intersection(this.usrClip.getBounds());
               }
               break;
            case 2:
               PathIterator var2 = this.usrClip.getPathIterator((AffineTransform)null);
               int[] var3 = new int[4];
               ShapeSpanIterator var4 = new ShapeSpanIterator();
               var4.setOutputArea(this.devClip);
               var4.appendPath(var2);
               var4.getPathBox(var3);
               Rectangle var6 = new Rectangle(var3[0], var3[1], var3[2] - var3[0], var3[3] - var3[1]);
               var1 = var6.intersection(this.devClip);
               Region var5 = new Region();
               var5.setOutputArea(var1);
               var5.appendSpans(var4);
               this.clipRegion = var5;
         }

         this.compBounds = var1;
      }

      return var1;
   }

   protected BufferedImage convertCM(BufferedImage var1, ColorModel var2) {
      WritableRaster var3 = var2.createCompatibleWritableRaster(var1.getWidth(), var1.getHeight());
      BufferedImage var4 = new BufferedImage(var2, var3, var1.isAlphaPremultiplied(), (Hashtable)null);

      for(int var5 = 0; var5 < var1.getHeight(); ++var5) {
         for(int var6 = 0; var6 < var1.getWidth(); ++var6) {
            var4.setRGB(var6, var5, var1.getRGB(var6, var5));
         }
      }

      return var4;
   }

   public WritableRaster convertRaster(Raster var1, ColorModel var2, ColorModel var3) {
      if (!(var2 instanceof IndexColorModel) || !var3.equals(ColorModel.getRGBdefault()) && !var3.equals(XRGBModel)) {
         BufferedImage var8 = new BufferedImage(var3, var3.createCompatibleWritableRaster(var1.getWidth(), var1.getHeight()), var3.isAlphaPremultiplied(), (Hashtable)null);
         Object var9 = var1.getDataElements(0, 0, (Object)null);

         for(int var6 = 0; var6 < var8.getHeight(); ++var6) {
            for(int var7 = 0; var7 < var8.getWidth(); ++var7) {
               var8.setRGB(var7, var6, var2.getRGB(var1.getDataElements(var7, var6, var9)));
            }
         }

         return var8.getRaster();
      } else {
         IndexColorModel var4 = (IndexColorModel)var2;
         BufferedImage var5 = var4.convertToIntDiscrete(var1, false);
         return var5.getRaster();
      }
   }

   private static float veclength(float var0, float var1) {
      return (float)Math.sqrt((double)(var0 * var0 + var1 * var1));
   }

   public Font getFont() {
      if (this.font == null) {
         this.font = new Font("Dialog", 10, 0);
      }

      return this.font;
   }

   public void setFont(Font var1) {
      if (var1 != null && var1 != this.font) {
         this.font = var1;
         this.fontMetrics = null;
         this.dscc = null;
         this.dbcc = null;
         this.dccc = null;
         this.dvcc = null;
      }

   }

   public static synchronized FontMetrics makeFontMetrics(Font var0, FontRenderContext var1) {
      boolean var2 = var1.isAntiAliased();
      boolean var3 = var1.usesFractionalMetrics();

      int var4;
      for(var4 = 0; var4 < metricscache.length; ++var4) {
         CachedMetrics var5 = metricscache[var4];
         if (var5 == null) {
            break;
         }

         if (var5.matches(var0, var2, var3)) {
            if (var4 > 1) {
               System.arraycopy(metricscache, 0, metricscache, 1, var4);
               metricscache[0] = var5;
            }

            return var5.fm;
         }
      }

      FontDesignMetrics var6 = new FontDesignMetrics(var0, var1);
      if (var4 == metricscache.length) {
         System.arraycopy(metricscache, 0, metricscache, 1, var4 - 1);
         var4 = 0;
      }

      metricscache[var4] = new CachedMetrics(var0, var2, var3, var6);
      return var6;
   }

   public FontMetrics getFontMetrics(Font var1) {
      if (this.fontMetrics != null && var1 == this.font) {
         return this.fontMetrics;
      } else {
         FontMetrics var2 = makeFontMetrics(var1, this.getFontRenderContext());
         if (this.font == var1) {
            this.fontMetrics = var2;
         }

         return var2;
      }
   }

   public boolean hit(Rectangle var1, Shape var2, boolean var3) {
      if (var3) {
         var2 = this.stroke.createStrokedShape(var2);
      }

      var2 = this.transformShape(var2);
      if ((this.constrainX | this.constrainY) != 0) {
         var1 = new Rectangle(var1);
         var1.translate(this.constrainX, this.constrainY);
      }

      return var2.intersects(var1);
   }

   public abstract ColorModel getDeviceColorModel();

   public abstract GraphicsConfiguration getDeviceConfiguration();

   public abstract OutputManager getOutputManager();

   public void setComposite(Composite var1) {
      if (var1 == null) {
         throw new IllegalArgumentException("null Composite");
      } else {
         byte var2;
         byte var3;
         if (var1 instanceof AlphaComposite) {
            var3 = 0;
            AlphaComposite var4 = (AlphaComposite)var1;
            if (!(var4.getAlpha() >= 1.0F) || var4.getRule() != 2 && var4.getRule() != 3) {
               var2 = 1;
            } else {
               var2 = 0;
            }
         } else if (var1 instanceof XORComposite) {
            var3 = 1;
            var2 = 2;
         } else {
            this.checkCustomComposite();
            var3 = 0;
            var2 = 3;
         }

         if (this.compositeState == var2 && this.modeState == var3) {
            this.dscc = null;
            this.dbcc = null;
            this.dccc = null;
            this.dvcc = null;
         } else {
            this.compositeState = var2;
            this.modeState = var3;
            this.invalidatePipe();
         }

         this.composite = var1;
      }
   }

   protected void checkCustomComposite() {
      SecurityManager var1 = System.getSecurityManager();
      if (var1 != null) {
         if (compPermission == null) {
            compPermission = new AWTPermission("readDisplayPixels");
         }

         var1.checkPermission(compPermission);
      }

   }

   public void setPaint(Paint var1) {
      if (var1 != null) {
         int var2 = this.paintState;
         this.paint = var1;
         if (var1 instanceof Color) {
            this.foregroundColor = (Color)var1;
            if (this.foregroundColor.getAlpha() == 255) {
               this.paintState = 0;
            } else {
               this.paintState = 1;
            }
         } else {
            this.paintState = 2;
         }

         if (this.paintState != var2) {
            this.invalidatePipe();
         } else {
            this.dscc = null;
            this.dbcc = null;
            this.dccc = null;
            this.dvcc = null;
         }

      }
   }

   public void setStroke(Stroke var1) {
      if (var1 == null) {
         throw new IllegalArgumentException("null Stroke");
      } else {
         int var2 = this.strokeState;
         boolean var3 = !this.stroke.equals(var1);
         this.stroke = var1;
         if (var1 instanceof BasicStroke) {
            this.strokeState = 0;
         } else {
            var3 = true;
            this.strokeState = 1;
         }

         if (var3) {
            this.invalidatePipe();
         }

      }
   }

   public void setRenderingHint(RenderingHints.Key var1, Object var2) {
      if (!var1.isCompatibleValue(var2)) {
         throw new IllegalArgumentException(var2 + " is not compatible with " + var1);
      } else {
         if (var1 instanceof SunHints.Key) {
            boolean var4 = true;
            SunHints.Key var5 = (SunHints.Key)var1;
            int var6 = ((SunHints.Value)var2).getIndex();
            boolean var3;
            switch (var5.getIndex()) {
               case 0:
                  var3 = this.renderHint != var6;
                  this.renderHint = var6;
                  break;
               case 1:
                  var3 = this.antialiasHint != var6;
                  this.antialiasHint = var6;
                  break;
               case 2:
                  var3 = this.textAntialiasHint != var6;
                  if (var3) {
                     this.fontMetrics = null;
                  }

                  this.textAntialiasHint = var6;
                  break;
               case 3:
                  var3 = this.fractionalMetricsHint != var6;
                  if (var3) {
                     this.fontMetrics = null;
                  }

                  this.fractionalMetricsHint = var6;
                  break;
               case 4:
               case 6:
               case 7:
               default:
                  var4 = false;
                  var3 = false;
                  break;
               case 5:
                  switch (var6) {
                     case 0:
                     default:
                        var6 = 1;
                        break;
                     case 1:
                     case 2:
                        var6 = 2;
                  }

                  var3 = this.interpolationHint != var6;
                  this.interpolationHint = var6;
                  break;
               case 8:
                  var3 = this.strokeHint != var6;
                  this.strokeHint = var6;
            }

            if (var4) {
               if (var3) {
                  this.invalidatePipe();
               }

               if (this.hints != null) {
                  this.hints.put(var1, var2);
               }

               return;
            }
         }

         if (this.hints == null) {
            this.hints = this.makeHints((Map)null);
         }

         this.hints.put(var1, var2);
      }
   }

   public Object getRenderingHint(RenderingHints.Key var1) {
      if (this.hints != null) {
         return this.hints.get(var1);
      } else if (!(var1 instanceof SunHints.Key)) {
         return null;
      } else {
         int var2 = ((SunHints.Key)var1).getIndex();
         switch (var2) {
            case 0:
               return Value.get(0, this.renderHint);
            case 1:
               return Value.get(1, this.antialiasHint);
            case 2:
               return Value.get(2, this.textAntialiasHint);
            case 3:
               return Value.get(3, this.fractionalMetricsHint);
            case 4:
            case 6:
            case 7:
            default:
               return null;
            case 5:
               switch (this.interpolationHint) {
                  case 1:
                     return SunHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
                  case 2:
                     return SunHints.VALUE_INTERPOLATION_BILINEAR;
                  default:
                     return null;
               }
            case 8:
               return Value.get(8, this.strokeHint);
         }
      }
   }

   public void setRenderingHints(Map var1) {
      this.hints = null;
      this.renderHint = 0;
      this.antialiasHint = 1;
      this.textAntialiasHint = 0;
      this.fractionalMetricsHint = 1;
      this.interpolationHint = -1;
      boolean var2 = false;

      for(Object var4 : var1.keySet()) {
         if (var4 != SunHints.KEY_RENDERING && var4 != SunHints.KEY_ANTIALIASING && var4 != SunHints.KEY_TEXT_ANTIALIASING && var4 != SunHints.KEY_FRACTIONALMETRICS && var4 != SunHints.KEY_STROKE_CONTROL && var4 != SunHints.KEY_INTERPOLATION) {
            var2 = true;
         } else {
            this.setRenderingHint((RenderingHints.Key)var4, var1.get(var4));
         }
      }

      if (var2) {
         this.hints = this.makeHints(var1);
      }

      this.invalidatePipe();
   }

   public void addRenderingHints(Map var1) {
      boolean var2 = false;

      for(Object var4 : var1.keySet()) {
         if (var4 != SunHints.KEY_RENDERING && var4 != SunHints.KEY_ANTIALIASING && var4 != SunHints.KEY_TEXT_ANTIALIASING && var4 != SunHints.KEY_FRACTIONALMETRICS && var4 != SunHints.KEY_STROKE_CONTROL && var4 != SunHints.KEY_INTERPOLATION) {
            var2 = true;
         } else {
            this.setRenderingHint((RenderingHints.Key)var4, var1.get(var4));
         }
      }

      if (var2) {
         if (this.hints == null) {
            this.hints = this.makeHints(var1);
         } else {
            this.hints.putAll(var1);
         }
      }

   }

   public RenderingHints getRenderingHints() {
      return this.hints == null ? this.makeHints((Map)null) : (RenderingHints)this.hints.clone();
   }

   RenderingHints makeHints(Map var1) {
      RenderingHints var2 = new RenderingHints(var1);
      var2.put(SunHints.KEY_RENDERING, Value.get(0, this.renderHint));
      var2.put(SunHints.KEY_ANTIALIASING, Value.get(1, this.antialiasHint));
      var2.put(SunHints.KEY_TEXT_ANTIALIASING, Value.get(2, this.textAntialiasHint));
      var2.put(SunHints.KEY_FRACTIONALMETRICS, Value.get(3, this.fractionalMetricsHint));
      Object var3;
      switch (this.interpolationHint) {
         case 1:
            var3 = SunHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
            break;
         case 2:
            var3 = SunHints.VALUE_INTERPOLATION_BILINEAR;
            break;
         default:
            return var2;
      }

      var2.put(SunHints.KEY_INTERPOLATION, var3);
      var2.put(SunHints.KEY_STROKE_CONTROL, Value.get(8, this.strokeHint));
      return var2;
   }

   public void translate(double var1, double var3) {
      this.transform.translate(var1, var3);
      this.invalidateTransform();
   }

   public void rotate(double var1) {
      this.transform.rotate(var1);
      this.invalidateTransform();
   }

   public void rotate(double var1, double var3, double var5) {
      this.transform.rotate(var1, var3, var5);
      this.invalidateTransform();
   }

   public void scale(double var1, double var3) {
      this.transform.scale(var1, var3);
      this.invalidateTransform();
   }

   public void shear(double var1, double var3) {
      this.transform.shear(var1, var3);
      this.invalidateTransform();
   }

   public void transform(AffineTransform var1) {
      this.transform.concatenate(var1);
      this.invalidateTransform();
   }

   public void translate(int var1, int var2) {
      this.transform.translate((double)var1, (double)var2);
      if (!this.complexTransform) {
         this.transX += var1;
         this.transY += var2;
         this.transformState = this.transX == 0 && this.transY == 0 ? 0 : 1;
         this.invalidatePipe();
      } else {
         this.invalidateTransform();
      }

   }

   public void setTransform(AffineTransform var1) {
      if ((this.constrainX | this.constrainY) == 0) {
         this.transform.setTransform(var1);
      } else {
         this.transform.setToTranslation((double)this.constrainX, (double)this.constrainY);
         this.transform.concatenate(var1);
      }

      this.invalidateTransform();
   }

   protected void invalidateTransform() {
      this.complexTransform = true;
      int var1 = this.transform.getType();
      if (var1 == 0) {
         this.transformState = 0;
         this.complexTransform = false;
         this.transX = this.transY = 0;
      } else if (var1 == 1) {
         this.transformState = 1;
         this.transX = (int)this.transform.getTranslateX();
         this.transY = (int)this.transform.getTranslateY();
      } else {
         this.transformState = 2;
         this.transX = this.transY = 0;
      }

      this.invalidatePipe();
   }

   public AffineTransform getTransform() {
      if ((this.constrainX | this.constrainY) == 0) {
         return new AffineTransform(this.transform);
      } else {
         AffineTransform var1 = AffineTransform.getTranslateInstance((double)(-this.constrainX), (double)(-this.constrainY));
         var1.concatenate(this.transform);
         return var1;
      }
   }

   public AffineTransform cloneTransform() {
      return new AffineTransform(this.transform);
   }

   public Paint getPaint() {
      return this.paint;
   }

   public Composite getComposite() {
      return this.composite;
   }

   public Color getColor() {
      return this.foregroundColor;
   }

   public void setColor(Color var1) {
      if (this.paint != var1) {
         this.setPaint(var1);
      }

   }

   public void setBackground(Color var1) {
      this.backgroundColor = var1;
   }

   public Color getBackground() {
      return this.backgroundColor;
   }

   public Stroke getStroke() {
      return this.stroke;
   }

   public Rectangle getClipBounds() {
      Shape var1 = this.getClip();
      return var1 != null ? var1.getBounds() : null;
   }

   protected void invalidateClip() {
      this.compBounds = null;
      this.clipRegion = null;
      if (this.usrClip == null) {
         this.clipState = 0;
      } else if (this.usrClip instanceof Rectangle2D) {
         this.clipState = 1;
      } else {
         this.clipState = 2;
      }

      this.invalidatePipe();
   }

   protected Shape transformShape(Shape var1) {
      if (var1 == null) {
         return null;
      } else {
         return this.complexTransform ? transformShape(this.transform, var1) : transformShape(this.transX, this.transY, var1);
      }
   }

   protected Shape untransformShape(Shape var1) {
      if (var1 == null) {
         return null;
      } else if (this.complexTransform) {
         try {
            return transformShape(this.transform.createInverse(), var1);
         } catch (NoninvertibleTransformException var3) {
            return null;
         }
      } else {
         return transformShape(-this.transX, -this.transY, var1);
      }
   }

   protected static Shape transformShape(int var0, int var1, Shape var2) {
      if (var2 == null) {
         return null;
      } else if (var2 instanceof Rectangle) {
         Rectangle var5 = var2.getBounds();
         var5.translate(var0, var1);
         return var5;
      } else if (var2 instanceof Rectangle2D) {
         Rectangle2D var4 = (Rectangle2D)var2;
         return new Rectangle2D.Double(((RectangularShape)var4).getX() + (double)var0, ((RectangularShape)var4).getY() + (double)var1, ((RectangularShape)var4).getWidth(), ((RectangularShape)var4).getHeight());
      } else if (var0 == 0 && var1 == 0) {
         return cloneShape(var2);
      } else {
         AffineTransform var3 = AffineTransform.getTranslateInstance((double)var0, (double)var1);
         return var3.createTransformedShape(var2);
      }
   }

   protected static Shape transformShape(AffineTransform var0, Shape var1) {
      if (var1 == null) {
         return null;
      } else if (var1 instanceof Rectangle2D && (var0.getType() & 48) == 0) {
         RectangularShape var2 = (Rectangle2D)var1;
         double[] var3 = new double[]{var2.getX(), var2.getY(), (double)0.0F, (double)0.0F};
         var3[2] = var3[0] + var2.getWidth();
         var3[3] = var3[1] + var2.getHeight();
         var0.transform(var3, 0, var3, 0, 2);
         var2 = new Rectangle2D.Float();
         var2.setFrameFromDiagonal(var3[0], var3[1], var3[2], var3[3]);
         return var2;
      } else {
         return var0.isIdentity() ? cloneShape(var1) : var0.createTransformedShape(var1);
      }
   }

   public void clipRect(int var1, int var2, int var3, int var4) {
      this.clip(new Rectangle(var1, var2, var3, var4));
   }

   public void setClip(int var1, int var2, int var3, int var4) {
      this.setClip(new Rectangle(var1, var2, var3, var4));
   }

   public Shape getClip() {
      return this.untransformShape(this.usrClip);
   }

   public void setClip(Shape var1) {
      this.usrClip = this.transformShape(var1);
      this.invalidateClip();
   }

   public void clip(Shape var1) {
      var1 = this.transformShape(var1);
      if (this.usrClip != null) {
         var1 = this.intersectShapes(this.usrClip, var1, true, true);
      }

      this.usrClip = var1;
      this.invalidateClip();
   }

   public void setPaintMode() {
      this.modeState = 0;
      this.xorColor = nullXORColor;
      this.setComposite(AlphaComposite.SrcOver);
   }

   public void setXORMode(Color var1) {
      if (var1 == null) {
         throw new IllegalArgumentException("null XORColor");
      } else {
         this.modeState = 1;
         this.xorColor = var1;
         this.setComposite(new XORComposite(var1));
      }
   }

   public void copyArea(int var1, int var2, int var3, int var4, int var5, int var6) {
      Rectangle var7 = new Rectangle(var1, var2, var3, var4);
      var7 = this.transformBounds(var7, this.transform);
      Point2D.Float var8 = new Point2D.Float((float)var5, (float)var6);
      Point2D.Float var9 = new Point2D.Float(0.0F, 0.0F);
      Point2D var24 = this.transform.transform(var8, var8);
      Point2D var25 = this.transform.transform(var9, var9);
      int var10 = (int)(var24.getX() - var25.getX());
      int var11 = (int)(var24.getY() - var25.getY());
      Rectangle var12 = this.getCompBounds().intersection(var7.getBounds());
      if (!var12.isEmpty()) {
         boolean var13 = true;
         Object var14 = null;
         if (this.clipState != 2) {
            this.copyAreaStateCache = this.getOutputManager().copyArea(this, (byte[])null, var12.width, 0, var12.x, var12.y, var12.width, var12.height, var10, var11, this.copyAreaStateCache);
         } else {
            int[] var15 = new int[4];
            this.clipRegion.getBounds(var15);
            Rectangle var16 = new Rectangle(var15[0], var15[1], var15[2] - var15[0], var15[3] - var15[1]);
            if (!var16.isEmpty()) {
               OutputManager var17 = this.getOutputManager();
               RegionIterator var18 = this.clipRegion.getIterator();

               while(var18.nextYRange(var15)) {
                  int var19 = var15[0];

                  int var21;
                  int var22;
                  for(int var20 = var15[1] - var19; var18.nextXBand(var15); this.copyAreaStateCache = var17.copyArea(this, (byte[])null, var22, 0, var21, var19, var22, var20, var10, var11, this.copyAreaStateCache)) {
                     var21 = var15[2];
                     var22 = var15[3] - var21;
                  }
               }
            }

         }
      }
   }

   public void drawLine(int var1, int var2, int var3, int var4) {
      this.drawpipe.drawLine(this, var1, var2, var3, var4);
   }

   public void drawRoundRect(int var1, int var2, int var3, int var4, int var5, int var6) {
      this.drawpipe.drawRoundRect(this, var1, var2, var3, var4, var5, var6);
   }

   public void fillRoundRect(int var1, int var2, int var3, int var4, int var5, int var6) {
      this.fillpipe.fillRoundRect(this, var1, var2, var3, var4, var5, var6);
   }

   public void drawOval(int var1, int var2, int var3, int var4) {
      this.drawpipe.drawOval(this, var1, var2, var3, var4);
   }

   public void fillOval(int var1, int var2, int var3, int var4) {
      this.fillpipe.fillOval(this, var1, var2, var3, var4);
   }

   public void drawArc(int var1, int var2, int var3, int var4, int var5, int var6) {
      this.drawpipe.drawArc(this, var1, var2, var3, var4, var5, var6);
   }

   public void fillArc(int var1, int var2, int var3, int var4, int var5, int var6) {
      this.fillpipe.fillArc(this, var1, var2, var3, var4, var5, var6);
   }

   public void drawPolyline(int[] var1, int[] var2, int var3) {
      this.drawpipe.drawPolyline(this, var1, var2, var3);
   }

   public void drawPolygon(int[] var1, int[] var2, int var3) {
      this.drawpipe.drawPolygon(this, var1, var2, var3);
   }

   public void fillPolygon(int[] var1, int[] var2, int var3) {
      this.fillpipe.fillPolygon(this, var1, var2, var3);
   }

   public void drawRect(int var1, int var2, int var3, int var4) {
      this.drawpipe.drawRect(this, var1, var2, var3, var4);
   }

   public void fillRect(int var1, int var2, int var3, int var4) {
      this.fillpipe.fillRect(this, var1, var2, var3, var4);
   }

   public void clearRect(int var1, int var2, int var3, int var4) {
      Composite var5 = this.composite;
      Paint var6 = this.paint;
      Color var7 = this.xorColor;
      boolean var8 = this.modeState == 1;
      this.setComposite(AlphaComposite.Src);
      this.setColor(this.getBackground());
      if (var8) {
         this.setPaintMode();
      }

      this.validatePipe();
      this.fillRect(var1, var2, var3, var4);
      if (var8) {
         this.setXORMode(var7);
      }

      this.setPaint(var6);
      this.setComposite(var5);
   }

   public void draw(Shape var1) {
      this.shapepipe.draw(this, var1);
   }

   public void fill(Shape var1) {
      this.shapepipe.fill(this, var1);
   }

   protected boolean drawImage(BufferedImage var1, int var2, int var3, Color var4, ImageObserver var5) {
      this.renderingPipeImage(var1, var2, var3, (BufferedImageOp)null, (AffineTransform)null, var4);
      return true;
   }

   protected boolean drawImage(BufferedImage var1, int var2, int var3, int var4, int var5, Color var6, ImageObserver var7) {
      if (var4 != 0 && var5 != 0) {
         AffineTransform var8 = null;
         if (var4 != var1.getWidth() || var5 != var1.getHeight()) {
            var8 = new AffineTransform();
            var8.scale((double)var4 / (double)var1.getWidth(), (double)var5 / (double)var1.getHeight());
         }

         return this.drawImage(var1, var8, var2, var3, var6, var7);
      } else {
         return true;
      }
   }

   protected boolean drawImage(BufferedImage var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9, Color var10, ImageObserver var11) {
      if (var2 != var4 && var3 != var5) {
         if (var6 != var8 && var7 != var9) {
            int var13;
            int var15;
            if (var9 > var7) {
               var13 = var9 - var7;
               var15 = var7;
            } else {
               var13 = var7 - var9;
               var15 = var9;
            }

            int var12;
            int var14;
            if (var8 > var6) {
               var12 = var8 - var6;
               var14 = var6;
            } else {
               var12 = var6 - var8;
               var14 = var8;
            }

            if (var4 <= var2) {
               ;
            }

            if (var5 <= var3) {
               ;
            }

            if (var12 > 0 && var13 > 0) {
               if (var14 >= 0 && var15 >= 0) {
                  WritableRaster var18 = var1.getRaster();
                  int var19 = ((Raster)var18).getWidth();
                  int var20 = ((Raster)var18).getHeight();
                  if (var14 + var12 > var19) {
                     var12 = var19 - var14;
                  }

                  if (var15 + var13 > var20) {
                     var13 = var20 - var15;
                  }

                  var1 = var1.getSubimage(var14 + var1.getMinX(), var15 + var1.getMinY(), var12, var13);
               }

               AffineTransform var23 = new AffineTransform();
               var23.translate((double)var2, (double)var3);
               if (var4 - var2 != var8 - var6 || var5 - var3 != var9 - var7) {
                  double var24 = (double)(var4 - var2) / (double)(var8 - var6);
                  double var21 = (double)(var5 - var3) / (double)(var9 - var7);
                  var23.scale(var24, var21);
               }

               var23.translate((double)(var14 - var6), (double)(var15 - var7));
               return this.drawImage(var1, var23, 0, 0, var10, var11);
            } else {
               return true;
            }
         } else {
            return true;
         }
      } else {
         return true;
      }
   }

   protected boolean drawImage(BufferedImage var1, AffineTransform var2, int var3, int var4, Color var5, ImageObserver var6) {
      this.renderingPipeImage(var1, var3, var4, (BufferedImageOp)null, var2, var5);
      return true;
   }

   public void drawImage(BufferedImage var1, BufferedImageOp var2, int var3, int var4) {
      this.renderingPipeImage(var1, var3, var4, var2, (AffineTransform)null, (Color)null);
   }

   public void drawRenderedImage(RenderedImage var1, AffineTransform var2) {
      if (var1 instanceof BufferedImage) {
         BufferedImage var23 = (BufferedImage)var1;
         ((Graphics2D)this).drawImage(var23, var2, (ImageObserver)null);
      } else {
         Rectangle var4 = this.getCompBounds();

         Raster var3;
         try {
            double[] var5 = new double[8];
            var5[0] = var5[2] = (double)var4.x;
            var5[4] = var5[6] = (double)(var4.x + var4.width);
            var5[1] = var5[5] = (double)var4.y;
            var5[3] = var5[7] = (double)(var4.y + var4.height);
            this.transform.inverseTransform(var5, 0, var5, 0, 4);
            var2.inverseTransform(var5, 0, var5, 0, 4);
            double var8;
            double var6 = var8 = var5[0];
            double var12;
            double var10 = var12 = var5[1];
            int var14 = 2;

            while(var14 < 8) {
               double var15 = var5[var14++];
               if (var15 < var6) {
                  var6 = var15;
               } else if (var15 > var8) {
                  var8 = var15;
               }

               var15 = var5[var14++];
               if (var15 < var10) {
                  var10 = var15;
               } else if (var15 > var12) {
                  var12 = var15;
               }
            }

            int var30 = (int)var6 - 3;
            int var16 = (int)(var8 - var6 + (double)6.0F);
            int var17 = (int)var10 - 3;
            int var18 = (int)(var12 - var10 + (double)6.0F);
            Rectangle var19 = new Rectangle(var30, var17, var16, var18);
            Rectangle var20 = new Rectangle(var1.getMinX(), var1.getMinY(), var1.getWidth(), var1.getHeight());
            Rectangle var21 = var19.intersection(var20);
            if (var21.width <= 0 || var21.height <= 0) {
               return;
            }

            var3 = var1.getData(var21);
         } catch (NoninvertibleTransformException var22) {
            var3 = var1.getData();
         }

         WritableRaster var24 = Raster.createWritableRaster(var3.getSampleModel(), var3.getDataBuffer(), (Point)null);
         int var25 = var3.getMinX();
         int var7 = var3.getMinY();
         int var26 = var25 - var3.getSampleModelTranslateX();
         int var9 = var7 - var3.getSampleModelTranslateY();
         if (var26 != 0 || var9 != 0) {
            var24 = var24.createWritableChild(var26, var9, var3.getWidth(), var3.getHeight(), 0, 0, (int[])null);
         }

         AffineTransform var27 = (AffineTransform)var2.clone();
         var27.translate((double)var25, (double)var7);
         BufferedImage var11 = new BufferedImage(var1.getColorModel(), var24, false, (Hashtable)null);
         ((Graphics2D)this).drawImage(var11, var27, (ImageObserver)null);
      }
   }

   public void drawRenderableImage(RenderableImage var1, AffineTransform var2) {
      AffineTransform var3 = this.transform;
      AffineTransform var4 = new AffineTransform(var2);
      var4.concatenate(var3);
      RenderContext var6 = new RenderContext(var4);

      AffineTransform var5;
      try {
         var5 = var3.createInverse();
      } catch (NoninvertibleTransformException var8) {
         var6 = new RenderContext(var3);
         var5 = new AffineTransform();
      }

      RenderedImage var7 = var1.createRendering(var6);
      this.drawRenderedImage(var7, var5);
   }

   private ColorModel getTransformColorModel(BufferedImage var1, AffineTransform var2) {
      ColorModel var3 = var1.getColorModel();
      Object var4 = var3;
      if (var2.isIdentity()) {
         return var3;
      } else {
         int var5 = var2.getType();
         boolean var6 = (var5 & (24 | 32)) != 0;
         if (!var6 && var5 != 1 && var5 != 0) {
            double[] var7 = new double[4];
            var2.getMatrix(var7);
            var6 = var7[0] != (double)((int)var7[0]) || var7[3] != (double)((int)var7[3]);
         }

         if (this.renderHint != 2) {
            if (var3 instanceof IndexColorModel) {
               WritableRaster var12 = var1.getRaster();
               IndexColorModel var8 = (IndexColorModel)var3;
               if (var6 && var3.getTransparency() == 1) {
                  if (var12 instanceof BytePackedRaster) {
                     var4 = ColorModel.getRGBdefault();
                  } else {
                     double[] var9 = new double[6];
                     var2.getMatrix(var9);
                     if (var9[1] != (double)0.0F || var9[2] != (double)0.0F || var9[4] != (double)0.0F || var9[5] != (double)0.0F) {
                        int var10 = var8.getMapSize();
                        if (var10 < 256) {
                           int[] var11 = new int[var10 + 1];
                           var8.getRGBs(var11);
                           var11[var10] = 0;
                           var4 = new IndexColorModel(((ColorModel)var8).getPixelSize(), var10 + 1, var11, 0, true, var10, 0);
                        } else {
                           var4 = ColorModel.getRGBdefault();
                        }
                     }
                  }
               }
            } else if (var6 && var3.getTransparency() == 1) {
               var4 = ColorModel.getRGBdefault();
            }
         } else if (var3 instanceof IndexColorModel || var6 && var3.getTransparency() == 1) {
            var4 = ColorModel.getRGBdefault();
         }

         return (ColorModel)var4;
      }
   }

   protected Rectangle transformBounds(Rectangle var1, AffineTransform var2) {
      if (var2.isIdentity()) {
         return var1;
      } else {
         Shape var3 = transformShape(var2, var1);
         return var3.getBounds();
      }
   }

   private void renderingPipeImage(BufferedImage var1, int var2, int var3, BufferedImageOp var4, AffineTransform var5, Color var6) {
      Rectangle var7 = this.getCompBounds();
      int var8 = this.interpolationHint;
      if (var4 == null && (var5 == null || var5.isIdentity()) && this.clipState != 2 && this.transformState != 2) {
         int var34 = var7.x;
         int var38 = var7.y;
         int var41 = var7.width;
         int var42 = var7.height;
         float var43 = (float)var2;
         float var46 = (float)var3;
         if (this.transformState == 1) {
            var43 = (float)((double)var43 + this.transform.getTranslateX());
            var46 = (float)((double)var46 + this.transform.getTranslateY());
         }

         float var49 = var43 + (float)var1.getWidth();
         float var51 = var46 + (float)var1.getHeight();
         if (var43 > (float)var34) {
            var41 = var41 + var34 - (int)var43;
            var34 = (int)var43;
         }

         if (var46 > (float)var38) {
            var42 = var42 + var38 - (int)var46;
            var38 = (int)var46;
         }

         if (var49 < (float)(var34 + var41)) {
            var41 = (int)var49 - var34;
         }

         if (var51 < (float)(var38 + var42)) {
            var42 = (int)var51 - var38;
         }

         if (var41 > 0 && var42 > 0) {
            if ((float)var34 > var43 || (float)var38 > var46) {
               var1 = var1.getSubimage(var1.getMinX() + (var34 - (int)var43), var1.getMinY() + (var38 - (int)var46), var41, var42);
            }

            this.rpics = RasterOutputManager.getManager().renderImage(this, var1, var6, var34, var38, var41, var42, (byte[])null, var41, this.rpics);
         }
      } else {
         AffineTransform var9 = null;
         if (var4 != null) {
            if (var4 instanceof AffineTransformOp) {
               AffineTransformOp var10 = (AffineTransformOp)var4;
               var9 = var10.getTransform();
               var8 = var10.getInterpolationType();
            } else {
               var1 = var4.filter(var1, (BufferedImage)null);
            }
         }

         int var35 = var1.getWidth();
         int var11 = var1.getHeight();
         AffineTransform var12 = new AffineTransform(this.transform);
         var12.translate((double)var2, (double)var3);
         if (var5 != null && !var5.isIdentity()) {
            var12.concatenate(var5);
         }

         if (var9 != null && !var9.isIdentity()) {
            var12.concatenate(var9);
         }

         double[] var13 = new double[6];
         var12.getMatrix(var13);
         if (var13[0] == (double)1.0F && var13[1] == (double)0.0F && var13[2] == (double)0.0F && var13[3] == (double)1.0F) {
            var2 = (int)Math.round(var13[4]);
            var3 = (int)Math.round(var13[5]);
            Rectangle var44 = new Rectangle(var2, var3, var35, var11);
            var7 = var7.intersection(var44);
            if (var7.isEmpty()) {
               return;
            }

            if (!var7.equals(var44)) {
               var1 = var1.getSubimage(var7.x - var2, var7.y - var3, var7.width, var7.height);
               var35 = var7.width;
               var11 = var7.height;
            }
         } else {
            ColorModel var14 = this.getTransformColorModel(var1, var12);
            int var15 = var8;
            if (var8 == -1) {
               var15 = this.renderHint == 2 ? 2 : 1;
            }

            AffineTransformOp var16 = new AffineTransformOp(var12, var15);
            Rectangle var17 = var16.getBounds2D(var1).getBounds();
            var7 = var7.intersection(var17);
            if (var7.isEmpty()) {
               return;
            }

            var2 = var7.x;
            var3 = var7.y;
            var35 = var7.width;
            var11 = var7.height;
            if (var2 != 0 || var3 != 0) {
               var12.preConcatenate(new AffineTransform((double)1.0F, (double)0.0F, (double)0.0F, (double)1.0F, (double)(-var2), (double)(-var3)));
               var16 = new AffineTransformOp(var12, var15);
            }

            BufferedImage var18;
            if (var14 == var1.getColorModel()) {
               var18 = new BufferedImage(var14, var1.getRaster().createCompatibleWritableRaster(var35, var11), var14.isAlphaPremultiplied(), (Hashtable)null);
            } else {
               var18 = new BufferedImage(var14, var14.createCompatibleWritableRaster(var35, var11), var14.isAlphaPremultiplied(), (Hashtable)null);
            }

            var1 = var16.filter(var1, var18);
            if (var1 == null) {
               return;
            }
         }

         if (this.clipState != 2) {
            this.getOutputManager().renderImage(this, var1, var6, var7.x, var7.y, var7.width, var7.height, (byte[])null, var7.width, (Object)null);
         } else {
            int[] var45 = new int[4];
            this.clipRegion.getBounds(var45);
            Rectangle var47 = new Rectangle(var45[0], var45[1], var45[2] - var45[0], var45[3] - var45[1]);
            var47 = var47.intersection(var7);
            if (!var47.isEmpty()) {
               OutputManager var50 = this.getOutputManager();
               RegionIterator var52 = this.clipRegion.getIterator();
               int var19 = var7.x;
               int var20 = var7.y;
               int var21 = var19 + var7.width;
               int var22 = var20 + var7.height;

               int var23;
               while(var52.nextYRange(var45) && (var23 = var45[0]) <= var22) {
                  int var24;
                  if ((var24 = var45[1]) >= var20) {
                     if (var23 < var20) {
                        var23 = var20;
                     }

                     if (var24 > var22) {
                        var24 = var22;
                     }

                     int var25 = var24 - var23;

                     int var26;
                     while(var52.nextXBand(var45) && (var26 = var45[2]) <= var21) {
                        int var27;
                        if ((var27 = var45[3]) >= var19) {
                           if (var26 < var19) {
                              var26 = var19;
                           }

                           if (var27 > var21) {
                              var27 = var21;
                           }

                           int var28 = var27 - var26;
                           BufferedImage var53 = var1.getSubimage(var26 - var19, var23 - var20, var28, var25);
                           var50.renderImage(this, var53, var6, var26, var23, var28, var25, (byte[])null, var28, (Object)null);
                        }
                     }
                  }
               }
            }

         }
      }
   }

   public void drawString(String var1, int var2, int var3) {
      if (var1 == null) {
         throw new NullPointerException("string is null");
      } else {
         try {
            this.dscc = this.textpipe.drawString(this, var1, (float)var2, (float)var3, this.dscc);
         } catch (ShapingException var6) {
            TextLayout var5 = new TextLayout(var1, this.getFont(), this.getFontRenderContext());
            var5.draw(this, (float)var2, (float)var3);
         }

      }
   }

   public void drawString(String var1, float var2, float var3) {
      if (var1 == null) {
         throw new NullPointerException("string is null");
      } else {
         try {
            this.dscc = this.textpipe.drawString(this, var1, var2, var3, this.dscc);
         } catch (ShapingException var6) {
            TextLayout var5 = new TextLayout(var1, this.getFont(), this.getFontRenderContext());
            var5.draw(this, var2, var3);
         }

      }
   }

   public void drawString(AttributedCharacterIterator var1, int var2, int var3) {
      if (var1 == null) {
         throw new NullPointerException("attributedcharacteriterator is null");
      } else {
         TextLayout var4 = new TextLayout(var1, this.getFontRenderContext());
         var4.draw(this, (float)var2, (float)var3);
      }
   }

   public void drawString(AttributedCharacterIterator var1, float var2, float var3) {
      if (var1 == null) {
         throw new NullPointerException("attributedcharacteriterator is null");
      } else {
         TextLayout var4 = new TextLayout(var1, this.getFontRenderContext());
         var4.draw(this, var2, var3);
      }
   }

   public void drawGlyphVector(GlyphVector var1, float var2, float var3) {
      if (var1 == null) {
         throw new NullPointerException("glyphvector is null");
      } else {
         this.dvcc = this.textpipe.drawGlyphVector(this, var1, var2, var3, this.dvcc);
      }
   }

   public void drawChars(char[] var1, int var2, int var3, int var4, int var5) {
      if (var1 == null) {
         throw new NullPointerException("char data is null");
      } else {
         try {
            this.dccc = this.textpipe.drawChars(this, var1, var2, var3, var4, var5, this.dccc);
         } catch (ShapingException var8) {
            TextLayout var7 = new TextLayout(new String(var1, var2, var3), this.getFont(), this.getFontRenderContext());
            var7.draw(this, (float)var4, (float)var5);
         }

      }
   }

   public void drawBytes(byte[] var1, int var2, int var3, int var4, int var5) {
      if (var1 == null) {
         throw new NullPointerException("byte data is null");
      } else {
         try {
            this.dbcc = this.textpipe.drawBytes(this, var1, var2, var3, var4, var5, this.dbcc);
         } catch (ShapingException var8) {
            TextLayout var7 = new TextLayout(new String(var1, 0, var2, var3), this.getFont(), this.getFontRenderContext());
            var7.draw(this, (float)var4, (float)var5);
         }

      }
   }

   public Object drawString(SunGraphics2D var1, String var2, float var3, float var4, Object var5) {
      return RasterOutputManager.getManager().drawString(var1, var2, var3, var4, var5);
   }

   public Object drawGlyphVector(SunGraphics2D var1, GlyphVector var2, float var3, float var4, Object var5) {
      return RasterOutputManager.getManager().drawGlyphVector(var1, var2, var3, var4, var5);
   }

   public Object drawChars(SunGraphics2D var1, char[] var2, int var3, int var4, int var5, int var6, Object var7) {
      return RasterOutputManager.getManager().drawChars(var1, var2, var3, var4, var5, var6, var7);
   }

   public Object drawBytes(SunGraphics2D var1, byte[] var2, int var3, int var4, int var5, int var6, Object var7) {
      return RasterOutputManager.getManager().drawBytes(var1, var2, var3, var4, var5, var6, var7);
   }

   public FontRenderContext getFontRenderContext() {
      int var1 = this.textAntialiasHint == 0 ? this.antialiasHint : this.textAntialiasHint;
      return new FontRenderContext(this.getDeviceConfiguration().getDefaultTransform(), var1 == 2, this.fractionalMetricsHint == 2);
   }

   public String getDevID() {
      return null;
   }

   public abstract ImageData lock(int var1, int var2, int var3, int var4, int var5);

   public abstract int unlock(ImageData var1);

   static {
      defaultComposite = AlphaComposite.SrcOver;
      invalidpipe = new ValidatePipe();
      metricscache = new CachedMetrics[5];
   }
}