//UPGRADE_NOTE: Synchronized keyword was removed from method 'deleteObserver'. Lock expression was added. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1027_3"' public virtual void deleteObserver(ImageObserver observer) { lock (this) { observers.remove(observer); } }
//UPGRADE_NOTE: Synchronized keyword was removed from method 'addObserver'. Lock expression was added. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1027_3"' public virtual void addObserver(ImageObserver observer) { lock (this) { observers.add(observer); } }
/// <summary> /// Gets a property of this image by name. /// <para> /// Individual property names are defined by the various image /// formats. If a property is not defined for a particular image, this /// method returns the <code>UndefinedProperty</code> object. /// </para> /// <para> /// If the properties for this image are not yet known, this method /// returns <code>null</code>, and the <code>ImageObserver</code> /// object is notified later. /// </para> /// <para> /// The property name <code>"comment"</code> should be used to store /// an optional comment which can be presented to the application as a /// description of the image, its source, or its author. /// </para> /// </summary> /// <param name="name"> a property name. </param> /// <param name="observer"> an object waiting for this image to be loaded. </param> /// <returns> the value of the named property. </returns> /// <exception cref="NullPointerException"> if the property name is null. </exception> /// <seealso cref= java.awt.image.ImageObserver </seealso> /// <seealso cref= java.awt.Image#UndefinedProperty </seealso> public abstract Object GetProperty(String name, ImageObserver observer);
public override object getProperty(string str, ImageObserver io) { throw new NotImplementedException(); }
/// <summary> /// 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. /// </summary> abstract public bool drawImage(Image @img, int @dx1, int @dy1, int @dx2, int @dy2, int @sx1, int @sy1, int @sx2, int @sy2, ImageObserver @observer);
/// <summary> /// Returns the status of the construction of a screen representation /// of the specified image. /// </summary> public int checkImage(Image @image, int @width, int @height, ImageObserver @observer) { return default(int); }
/// <summary> /// Renders an image, applying a transform from image space into user space /// before drawing. /// </summary> abstract public bool drawImage(Image @img, AffineTransform @xform, ImageObserver @obs);
/** * Renders 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 <code>Transform</code> in the <code>Graphics2D</code>. * The specified transformation is applied to the image before the * transform attribute in the <code>Graphics2D</code> context is applied. * The rendering attributes applied include the <code>Clip</code>, * <code>Transform</code>, and <code>Composite</code> attributes. * Note that no rendering is done if the specified transform is * noninvertible. * @param img the <code>Image</code> to be rendered * @param xform the transformation from image space into user space * @param obs the {@link ImageObserver} * to be notified as more of the <code>Image</code> * is Converted * @return <code>true</code> if the <code>Image</code> is * fully loaded and completely rendered; * <code>false</code> if the <code>Image</code> is still being loaded. * @see #_transform * @see #setTransform * @see #setComposite * @see #clip * @see #setClip(Shape) */ public bool DrawImage(Image img, AffineTransform xform, ImageObserver obs) { log.log(POILogger.WARN, "Not implemented"); return false; }
public override int getHeight(ImageObserver param) { return mHeight; }
public override bool drawImage(java.awt.Image img, java.awt.geom.AffineTransform xform, ImageObserver observer) { if (img == null) { return(true); } if (xform == null || xform.isIdentity()) { return(drawImage(img, 0, 0, null, observer)); } throw new NotImplementedException("drawImage(Image,AffineTransform,ImageObserver) not implemented for non-null or non-identity AffineTransform!"); }
/// <summary> /// Draws as much of the specified image as is currently available. /// </summary> public abstract bool drawImage(Image @img, int @x, int @y, Color @bgcolor, ImageObserver @observer);
/// <summary> /// Returns the status of the construction of a screen representation /// of the specified image. /// </summary> public int checkImage(Image @image, int @width, int @height, ImageObserver @observer) { return(default(int)); }
public override int getWidth(ImageObserver param) { return mWidth; }
/// <summary> /// Returns a property of the image by name. /// </summary> public object getProperty(string @name, ImageObserver @observer) { return(default(object)); }
public override object getProperty(string param, ImageObserver obs) { return null; }
/** * 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 bool DrawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgcolor, ImageObserver observer){ log.log(POILogger.WARN, "Not implemented"); return false; }
/// <summary> /// Returns the height of the <code>BufferedImage</code>. /// </summary> public int getHeight(ImageObserver @observer) { return default(int); }
/// <summary> /// Prepares an image for rendering on this component at the /// specified width and height. /// </summary> public bool prepareImage(Image @image, int @width, int @height, ImageObserver @observer) { return default(bool); }
/// <summary> /// Returns a property of the image by name. /// </summary> public object getProperty(string @name, ImageObserver @observer) { return default(object); }
public bool DrawImage(Image img, int x, int y, int width, int height, ImageObserver observer) { return DrawImage(img, x,y,width,height, null, observer); }
/// <summary> /// Returns the width of the <code>BufferedImage</code>. /// </summary> public int getWidth(ImageObserver @observer) { return default(int); }
public override int getHeight(ImageObserver io) { return(height); // bitmap.Height --> need invoke or lock }
private boolean drawImage(Image img, Image mask, AffineTransform xform, Color bgColor, ImageObserver obs) { if (xform == null) { return(true); } xform.translate(0, img.getHeight(obs)); xform.scale(img.getWidth(obs), img.getHeight(obs)); AffineTransform inverse = this.normalizeMatrix(); AffineTransform flipper = AffineTransform.getScaleInstance(1, -1); inverse.concatenate(xform); inverse.concatenate(flipper); double[] mx = new double[6]; inverse.getMatrix(mx); try { com.lowagie.text.Image image = com.lowagie.text.Image.getInstance(img, bgColor); if (mask != null) { com.lowagie.text.Image msk = com.lowagie.text.Image.getInstance(mask, null, true); msk.makeMask(); msk.setInvertMask(true); image.setImageMask(msk); } cb.addImage(image, (float)mx[0], (float)mx[1], (float)mx[2], (float)mx[3], (float)mx[4], (float)mx[5]); } catch (Exception ex) { throw new IllegalArgumentException(); } return(true); }
public override bool drawImage(java.awt.Image img, java.awt.geom.AffineTransform xform, ImageObserver observer) { if (img == null) { return true; } if (xform == null || xform.isIdentity()) { return drawImage(img, 0, 0, null, observer); } NetGraphics clone = (NetGraphics)create(); clone.transform(xform); bool rendered = clone.drawImage(img, 0, 0, null, observer); clone.dispose(); return rendered; }
/** * @see Graphics2D#drawImage(Image, AffineTransform, ImageObserver) */ public boolean drawImage(Image img, AffineTransform xform, ImageObserver obs) { return(drawImage(img, null, xform, null, obs)); }
/// <summary> /// Determines the height of the image. If the height is not yet known, /// this method returns <code>-1</code> and the specified /// <code>ImageObserver</code> object is notified later. </summary> /// <param name="observer"> an object waiting for the image to be loaded. </param> /// <returns> the height of this image, or <code>-1</code> /// if the height is not yet known. </returns> /// <seealso cref= java.awt.Image#getWidth </seealso> /// <seealso cref= java.awt.image.ImageObserver </seealso> public abstract int GetHeight(ImageObserver observer);
/** * @see Graphics#drawImage(Image, int, int, ImageObserver) */ public boolean drawImage(Image img, int x, int y, ImageObserver observer) { return(drawImage(img, x, y, null, observer)); }
/// <summary> /// Returns the status of the construction of a screen representation /// of the specified image. /// </summary> public int checkImage(Image @image, ImageObserver @observer) { return(default(int)); }
/** * @see Graphics#drawImage(Image, int, int, int, int, ImageObserver) */ public boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer) { return(drawImage(img, x, y, width, height, null, observer)); }
/// <summary> /// Returns the height of the <code>BufferedImage</code>. /// </summary> public int getHeight(ImageObserver @observer) { return(default(int)); }
/** * @see Graphics#drawImage(Image, int, int, Color, ImageObserver) */ public boolean drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer) { return(drawImage(img, x, y, img.getWidth(observer), img.getHeight(observer), bgcolor, observer)); }
/// <summary> /// Returns the width of the <code>BufferedImage</code>. /// </summary> public int getWidth(ImageObserver @observer) { return(default(int)); }
/** * @see Graphics#drawImage(Image, int, int, int, int, Color, ImageObserver) */ public boolean drawImage(Image img, int x, int y, int width, int height, Color bgcolor, ImageObserver observer) { double scalex = width / (double)img.getWidth(observer); double scaley = height / (double)img.getHeight(observer); AffineTransform tx = AffineTransform.getTranslateInstance(x, y); tx.scale(scalex, scaley); return(drawImage(img, null, tx, 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) */ public bool DrawImage(Image img, int x, int y, int width, int height, Color bgcolor, ImageObserver observer){ log.log(POILogger.WARN, "Not implemented"); return false; }
/** * @see Graphics#drawImage(Image, int, int, int, int, int, int, int, int, ImageObserver) */ public boolean drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer) { return(drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null, 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>, <i>y</i>) in this graphics context's coordinate * space. Transparent pixels in the image do not affect whatever * pixels are already there. * <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 completely loaded and its pixels are * no longer being Changed, then * <code>drawImage</code> returns <code>true</code>. * Otherwise, <code>drawImage</code> returns <code>false</code> * and as more of * the image becomes available * or it is time to Draw another frame of animation, * the process that loads the image notifies * the specified image observer. * @param img the specified image to be Drawn. This method does * nothing if <code>img</code> is null. * @param x the <i>x</i> coordinate. * @param y the <i>y</i> coordinate. * @param observer object to be notified as more of * the image is Converted. * @return <code>false</code> if the image pixels are still changing; * <code>true</code> otherwise. * @see java.awt.Image * @see java.awt.image.ImageObserver * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int) */ public bool DrawImage(Image img, int x, int y, ImageObserver observer) { log.log(POILogger.WARN, "Not implemented"); return false; }
/** * @see Graphics#drawImage(Image, int, int, int, int, int, int, int, int, Color, ImageObserver) */ 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) { double dwidth = (double)dx2 - dx1; double dheight = (double)dy2 - dy1; double swidth = (double)sx2 - sx1; double sheight = (double)sy2 - sy1; //if either width or height is 0, then there is nothing to draw if (dwidth == 0 || dheight == 0 || swidth == 0 || sheight == 0) { return(true); } double scalex = dwidth / swidth; double scaley = dheight / sheight; double transx = sx1 * scalex; double transy = sy1 * scaley; AffineTransform tx = AffineTransform.getTranslateInstance(dx1 - transx, dy1 - transy); tx.scale(scalex, scaley); BufferedImage mask = new BufferedImage(img.getWidth(observer), img.getHeight(observer), BufferedImage.TYPE_BYTE_BINARY); Graphics g = mask.getGraphics(); g.fillRect(sx1, sy1, (int)swidth, (int)sheight); drawImage(img, mask, tx, null, observer); return(true); }
/// <summary> /// Prepares an image for rendering on this component. /// </summary> public bool prepareImage(Image @image, ImageObserver @observer) { return default(bool); }
/// <summary> /// Draws as much of the specified image as has already been scaled /// to fit inside the specified rectangle. /// </summary> abstract public bool drawImage(Image @img, int @x, int @y, int @width, int @height, ImageObserver @observer);
/// <summary> /// Returns the status of the construction of a screen representation /// of the specified image. /// </summary> public int checkImage(Image @image, ImageObserver @observer) { return default(int); }
public void DrawImage(BufferedImage par1BufferedImage, int i, int i1, ImageObserver imageObserver) { Utils.Edge.Diagnostic.Internal.NotImplemented(); }
/// <summary> /// Draws as much of the specified image as is currently available. /// </summary> abstract public bool drawImage(Image @img, int @x, int @y, ImageObserver @observer);
public override bool drawImage(java.awt.Image img, java.awt.geom.AffineTransform xform, ImageObserver observer) { if (img == null) { return true; } if (xform == null || xform.isIdentity()) { return drawImage(img, 0, 0, null, observer); } throw new NotImplementedException("drawImage(Image,AffineTransform,ImageObserver) not implemented for non-null or non-identity AffineTransform!"); }
public override int getWidth(ImageObserver io) { return(width); // bitmap.Width --> need invoke or lock }
public override int getWidth(ImageObserver io) { return width; // bitmap.Width --> need invoke or lock }
public override int getHeight(ImageObserver io) { return height; // bitmap.Height --> need invoke or lock }
public override bool drawImage(java.awt.Image img, java.awt.geom.AffineTransform xform, ImageObserver observer) { checkState(); return base.drawImage(img, xform, observer); }
/// <summary> /// Prepares an image for rendering on this component. /// </summary> public bool prepareImage(Image @image, ImageObserver @observer) { return(default(bool)); }
/// <summary> /// Determines the width of the image. If the width is not yet known, /// this method returns <code>-1</code> and the specified /// <code>ImageObserver</code> object is notified later. </summary> /// <param name="observer"> an object waiting for the image to be loaded. </param> /// <returns> the width of this image, or <code>-1</code> /// if the width is not yet known. </returns> /// <seealso cref= java.awt.Image#getHeight </seealso> /// <seealso cref= java.awt.image.ImageObserver </seealso> public abstract int GetWidth(ImageObserver observer);
/// <summary> /// Prepares an image for rendering on this component at the /// specified width and height. /// </summary> public bool prepareImage(Image @image, int @width, int @height, ImageObserver @observer) { return(default(bool)); }
public abstract bool drawImage(Image img, int x, int y, ImageObserver observer);