int width, int height,                             ImageObserver observer) {         if (img == null) {            return true;        }        addDrawingRect(x, y, width, height);        mPrintMetrics.drawImage(this, img);         return mGraphics.drawImage(img, x, y, width, height, observer);     }     /**     * Draws as much of the specified image as is currently available.     * The image is drawn with its top-left corner at     * (<i>x</i>,&nbsp;<i>y</i>) in this graphics context's coordinate     * space.  Transparent pixels are drawn in the specified     * background color.     * <p>     * This operation is equivalent to filling a rectangle of the     * width and height of the specified image with the given color and then     * drawing the image on top of it, but possibly more efficient.     * <p>     * This method returns immediately in all cases, even if the     * complete image has not yet been loaded, and it has not been dithered     * and converted for the current output device.     * <p>     * If the image has not yet been completely loaded, then     * <code>drawImage</code> returns <code>false</code>. As more of     * the image becomes available, the process that draws the image notifies     * the specified image observer.     * @param    img    the specified image to be drawn.     * @param    x      the <i>x</i> coordinate.     * @param    y      the <i>y</i> coordinate.     * @param    bgcolor the background color to paint under the     *                         non-opaque portions of the image.     * @param    observer    object to be notified as more of     *                          the image is converted.     * @see      java.awt.Image     * @see      java.awt.image.ImageObserver     * @see      java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)     * @since    JDK1.0     */   public boolean drawImage(Image img, int x, int y,                             Color bgcolor,                             ImageObserver observer) {         if (img == null) {            return true;        }         /* The ImageWaiter creation does not return until the         * image is loaded.         */        ImageWaiter dim = new ImageWaiter(img);         addDrawingRect(x, y, dim.getWidth(), dim.getHeight());        mPrintMetrics.drawImage(this, img);         return mGraphics.drawImage(img, x, y, bgcolor, observer);    }      /**     * Draws as much of the specified image as has already been scaled     * to fit inside the specified rectangle.     * <p>     * The image is drawn inside the specified rectangle of this     * graphics context's coordinate space, and is scaled if     * necessary. Transparent pixels are drawn in the specified     * background color.     * This operation is equivalent to filling a rectangle of the     * width and height of the specified image with the given color and then     * drawing the image on top of it, but possibly more efficient.     * <p>     * This method returns immediately in all cases, even if the     * entire image has not yet been scaled, dithered, and converted     * for the current output device.     * If the current output representation is not yet complete then     * <code>drawImage</code> returns <code>false</code>. As more of     * the image becomes available, the process that draws the image notifies     * the specified image observer.     * <p>     * A scaled version of an image will not necessarily be     * available immediately just because an unscaled version of the     * image has been constructed for this output device.  Each size of     * the image may be cached separately and generated from the original     * data in a separate image production sequence.     * @param    img       the specified image to be drawn.     * @param    x         the <i>x</i> coordinate.     * @param    y         the <i>y</i> coordinate.     * @param    width     the width of the rectangle.     * @param    height    the height of the rectangle.     * @param    bgcolor   the background color to paint under the     *                         non-opaque portions of the image.     * @param    observer    object to be notified as more of     *                          the image is converted.     * @see      java.awt.Image     * @see      java.awt.image.ImageObserver     * @see      java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)     * @since    JDK1.0     */    public boolean drawImage(Image img, int x, int y,                             int width, int height,                             Color bgcolor,                             ImageObserver observer) {         if (img == null) {            return true;        }         addDrawingRect(x, y, width, height);        mPrintMetrics.drawImage(this, img);         return mGraphics.drawImage(img, x, y, width, height, bgcolor, observer);     }     /**     * Draws as much of the specified area of the specified image as is     * currently available, scaling it on the fly to fit inside the     * specified area of the destination drawable surface. Transparent pixels     * do not affect whatever pixels are already there.     * <p>     * This method returns immediately in all cases, even if the     * image area to be drawn has not yet been scaled, dithered, and converted     * for the current output device.     * If the current output representation is not yet complete then     * <code>drawImage</code> returns <code>false</code>. As more of     * the image becomes available, the process that draws the image notifies     * the specified image observer.     * <p>     * This method always uses the unscaled version of the image     * to render the scaled rectangle and performs the required     * scaling on the fly. It does not use a cached, scaled version     * of the image for this operation. Scaling of the image from source     * to destination is performed such that the first coordinate     * of the source rectangle is mapped to the first coordinate of     * the destination rectangle, and the second source coordinate is     * mapped to the second destination coordinate. The subimage is     * scaled and flipped as needed to preserve those mappings.     * @param       img the specified image to be drawn     * @param       dx1 the <i>x</i> coordinate of the first corner of the     *                    destination rectangle.     * @param       dy1 the <i>y</i> coordinate of the first corner of the     *                    destination rectangle.     * @param       dx2 the <i>x</i> coordinate of the second corner of the     *                    destination rectangle.     * @param       dy2 the <i>y</i> coordinate of the second corner of the     *                    destination rectangle.     * @param       sx1 the <i>x</i> coordinate of the first corner of the     *                    source rectangle.     * @param       sy1 the <i>y</i> coordinate of the first corner of the     *                    source rectangle.     * @param       sx2 the <i>x</i> coordinate of the second corner of the     *                    source rectangle.     * @param       sy2 the <i>y</i> coordinate of the second corner of the     *                    source rectangle.     * @param       observer object to be notified as more of the image is     *                    scaled and converted.     * @see         java.awt.Image     * @see         java.awt.image.ImageObserver     * @see         java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)     * @since       JDK1.1     */    public boolean drawImage(Image img,                             int dx1, int dy1, int dx2, int dy2,                             int sx1, int sy1, int sx2, int sy2,                             ImageObserver observer) {         if (img == null) {            return true;        }         int width = dx2 - dx1;        int height = dy2 - dy1;         addDrawingRect(dx1, dy1, width, height);        mPrintMetrics.drawImage(this, img);         return mGraphics.drawImage(img, dx1, dy1, dx2, dy2,                               sx1, sy1, sx2, sy2, observer);     }      /**     * Draws as much of the specified area of the specified image as is     * currently available, scaling it on the fly to fit inside the     * specified area of the destination drawable surface.     * <p>     * Transparent pixels are drawn in the specified background color.     * This operation is equivalent to filling a rectangle of the     * width and height of the specified image with the given color and then     * drawing the image on top of it, but possibly more efficient.     * <p>     * This method returns immediately in all cases, even if the     * image area to be drawn has not yet been scaled, dithered, and converted     * for the current output device.     * If the current output representation is not yet complete then     * <code>drawImage</code> returns <code>false</code>. As more of     * the image becomes available, the process that draws the image notifies     * the specified image observer.     * <p>     * This method always uses the unscaled version of the image     * to render the scaled rectangle and performs the required     * scaling on the fly. It does not use a cached, scaled version     * of the image for this operation. Scaling of the image from source     * to destination is performed such that the first coordinate     * of the source rectangle is mapped to the first coordinate of     * the destination rectangle, and the second source coordinate is     * mapped to the second destination coordinate. The subimage is     * scaled and flipped as needed to preserve those mappings.     * @param       img the specified image to be drawn     * @param       dx1 the <i>x</i> coordinate of the first corner of the     *                    destination rectangle.     * @param       dy1 the <i>y</i> coordinate of the first corner of the     *                    destination rectangle.     * @param       dx2 the <i>x</i> coordinate of the second corner of the     *                    destination rectangle.     * @param       dy2 the <i>y</i> coordinate of the second corner of the     *                    destination rectangle.     * @param       sx1 the <i>x</i> coordinate of the first corner of the     *                    source rectangle.     * @param       sy1 the <i>y</i> coordinate of the first corner of the     *                    source rectangle.     * @param       sx2 the <i>x</i> coordinate of the second corner of the     *                    source rectangle.     * @param       sy2 the <i>y</i> coordinate of the second corner of the     *                    source rectangle.     * @param       bgcolor the background color to paint under the     *                    non-opaque portions of the image.     * @param       observer object to be notified as more of the image is     *                    scaled and converted.     * @see         java.awt.Image     * @see         java.awt.image.ImageObserver     * @see         java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)     * @since       JDK1.1     */    public boolean drawImage(Image img,                             int dx1, int dy1, int dx2, int dy2,                             int sx1, int sy1, int sx2, int sy2,                             Color bgcolor,                             ImageObserver observer) {         if (img == null) {            return true;        }         int width = dx2 - dx1;        int height = dy2 - dy1;         addDrawingRect(dx1, dy1, width, height);        mPrintMetrics.drawImage(this, img);         return mGraphics.drawImage(img, dx1, dy1, dx2, dy2,                               sx1, sy1, sx2, sy2, bgcolor, observer);     }      /**     * Draws an image, applying a transform from image space into user space     * before drawing.     * The transformation from user space into device space is done with     * the current transform in the Graphics2D.     * The given transformation is applied to the image before the     * transform attribute in the Graphics2D state is applied.     * The rendering attributes applied include the clip, transform,     * and composite attributes. Note that the result is     * undefined, if the given transform is noninvertible.     * @param img The image to be drawn.     * @param xform The transformation from image space into user space.     * @see #transform     * @see #setTransform     * @see #setComposite     * @see #clip     * @see #setClip     */    public void drawRenderedImage(RenderedImage img,                                  AffineTransform xform) {         if (img == null) {            return;        }         mPrintMetrics.drawImage(this, img);        mDrawingArea.addInfinite();    }      public void drawRenderableImage(RenderableImage img,                                    AffineTransform xform) {         if (img == null) {            return;        }         mPrintMetrics.drawImage(this, img);        mDrawingArea.addInfinite();    }     /**     * Disposes of this graphics context and releases     * any system resources that it is using.     * A <code>Graphics</code> object cannot be used after     * <code>dispose</code>has been called.     * <p>     * When a Java program runs, a large number of <code>Graphics</code>     * objects can be created within a short time frame.     * Although the finalization process of the garbage collector     * also disposes of the same system resources, it is preferable     * to manually free the associated resources by calling this     * method rather than to rely on a finalization process which     * may not run to completion for a long period of time.     * <p>     * Graphics objects which are provided as arguments to the     * <code>paint</code> and <code>update</code> methods     * of components are automatically released by the system when     * those methods return. For efficiency, programmers should     * call <code>dispose</code> when finished using     * a <code>Graphics</code> object only if it was created     * directly from a component or another <code>Graphics</code> object.     * @see         java.awt.Graphics#finalize     * @see         java.awt.Component#paint     * @see         java.awt.Component#update     * @see         java.awt.Component#getGraphics     * @see         java.awt.Graphics#create     * @since       JDK1.0     */    public void dispose() {        mGraphics.dispose();    }     /**     * Empty finalizer as no clean up needed here.     */    public void finalize() {    } /* The Delegated Graphics2D Methods */     /**     * Strokes the outline of a Shape using the settings of the current     * graphics state.  The rendering attributes applied include the     * clip, transform, paint or color, composite and stroke attributes.     * @param s The shape to be drawn.     * @see #setStroke     * @see #setPaint     * @see java.awt.Graphics#setColor     * @see #transform     * @see #setTransform     * @see #clip     * @see #setClip     * @see #setComposite     */    public void draw(Shape s) {        addStrokeShape(s);        mPrintMetrics.draw(this);    }      /**     * Draws an image, applying a transform from image space into user space     * before drawing.     * The transformation from user space into device space is done with     * the current transform in the Graphics2D.     * The given transformation is applied to the image before the     * transform attribute in the Graphics2D state is applied.     * The rendering attributes applied include the clip, transform,     * and composite attributes. Note that the result is     * undefined, if the given transform is noninvertible.     * @param img The image to be drawn.     * @param xform The transformation from image space into user space.     * @param obs The image observer to be notified as more of the image     * is converted.     * @see #transform     * @see #setTransform     * @see #setComposite     * @see #clip     * @see #setClip     */    public boolean drawImage(Image img,                             AffineTransform xform,                             ImageObserver obs) {         if (img == null) {            return true;        }         mDrawingArea.addInfinite();        mPrintMetrics.drawImage(this, img);         return mGraphics.drawImage(img, xform, obs);  //      if (mDrawingArea[0] != null) {//          Rectangle2D.Double bbox = new Rectangle2D.Double();//          Point2D leftTop = new Point2D.Double(0, 0);//          Point2D rightBottom = new Point2D.Double(getImageWidth(img),//                                                   getImageHeight(img)); //          xform.transform(leftTop, leftTop);//          xform.transform(rightBottom, rightBottom); //          bbox.setBoundsFromDiagonal(leftTop, rightBottom);//          addDrawingRect(bbox); //      }    }      /**     * Draws a BufferedImage that is filtered with a BufferedImageOp.     * The rendering attributes applied include the clip, transform     * and composite attributes.  This is equivalent to:     * <pre>     * img1 = op.filter(img, null);     * drawImage(img1, new AffineTransform(1f,0f,0f,1f,x,y), null);     * </pre>     * @param op The filter to be applied to the image before drawing.     * @param img The BufferedImage to be drawn.     * @param x,y The location in user space where the image should be drawn.     * @see #transform     * @see #setTransform     * @see #setComposite     * @see #clip     * @see #setClip     */    public void drawImage(BufferedImage img,                          BufferedImageOp op,                          int x,                          int y) {         if (img == null) {            return;        }         mPrintMetrics.drawImage(this, (RenderedImage) img);        mDrawingArea.addInfinite();    }      /**     * Draws a string of text.     * The rendering attributes applied include the clip, transform,     * paint or color, font and composite attributes.     * @param s The string to be drawn.     * @param x,y The coordinates where the string should be drawn.     * @see #setPaint     * @see java.awt.Graphics#setColor     * @see java.awt.Graphics#setFont     * @see #transform     * @see #setTransform     * @see #setComposite     * @see #clip     * @see #setClip     */    public void drawString(String str,                           float x,                           float y) {         if (str.length() == 0) {            return;        }        /* Logical bounds close enough and is used for GlyphVector */        FontRenderContext frc = getFontRenderContext();        Rectangle2D bbox = getFont().getStringBounds(str, frc);        addDrawingRect(bbox, x, y);        mPrintMetrics.drawText(this);    }     /**     * Draws a GlyphVector.     * The rendering attributes applied include the clip, transform,     * paint or color, and composite attributes.  The GlyphVector specifies     * individual glyphs from a Font.     * @param g The GlyphVector to be drawn.     * @param x,y The coordinates where the glyphs should be drawn.     * @see #setPaint     * @see java.awt.Graphics#setColor     * @see #transform     * @see #setTransform     * @see #setComposite     * @see #clip     * @see #setClip     */    public void drawGlyphVector(GlyphVector g,                           float x,                           float y) {         Rectangle2D bbox = g.getLogicalBounds();        addDrawingRect(bbox, x, y);        mPrintMetrics.drawText(this);     }     /**     * Fills the interior of a Shape using the settings of the current

Lines 1001–1500 of 1918. Previous lines Load more