Java ImageObserver.HEIGHT属性代码示例

public void setDimensions(int w, int h) {
    if (src != null) {
        src.checkSecurity(null, false);
    }

    image.setDimensions(w, h);

    newInfo(image, (ImageObserver.WIDTH | ImageObserver.HEIGHT),
            0, 0, w, h);

    if (w <= 0 || h <= 0) {
        imageComplete(ImageConsumer.IMAGEERROR);
        return;
    }

    if (width != w || height != h) {
        // dimension mismatch => trigger recreation of the buffer
        bimage = null;
    }

    width = w;
    height = h;

    availinfo |= ImageObserver.WIDTH | ImageObserver.HEIGHT;
}
 

@Override
public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {

    if (image != img) {
        throw new RuntimeException("Original image is not passed to the observer");
    }

    if ((infoflags & ImageObserver.WIDTH) != 0) {
        if (width != IMAGE_WIDTH) {
            throw new RuntimeException("Original width is not passed to the observer");
        }
    }

    if ((infoflags & ImageObserver.HEIGHT) != 0) {
        if (height != IMAGE_HEIGHT) {
            throw new RuntimeException("Original height is not passed to the observer");
        }
    }

    return (infoflags & ALLBITS) == 0;
}
 

/**
 * Return the height of the original image source.
 * If the height isn't known, then the image is reconstructed.
 */
public int getHeight() {
    if (src != null) {
        src.checkSecurity(null, false);
    }
    if ((availinfo & ImageObserver.HEIGHT) == 0) {
        reconstruct(ImageObserver.HEIGHT);
    }
    return height;
}
 

public int check(ImageObserver iw) {
    if (src != null) {
        src.checkSecurity(null, false);
    }
    if ((availinfo & ImageObserver.ERROR) == 0 &&
        ((~availinfo) & (ImageObserver.WIDTH |
                         ImageObserver.HEIGHT |
                         ImageObserver.PROPERTIES)) != 0) {
        addWatcher(iw, false);
    }
    return availinfo;
}
 

synchronized void infoDone(int status) {
    if (status == ImageConsumer.IMAGEERROR ||
        ((~availinfo) & (ImageObserver.WIDTH |
                         ImageObserver.HEIGHT)) != 0) {
        addInfo(ImageObserver.ERROR);
    } else if ((availinfo & ImageObserver.PROPERTIES) == 0) {
        setProperties(null);
    }
}
 

public static ImageObserver getResolutionVariantObserver(
        final Image image, final ImageObserver observer,
        final int imgWidth, final int imgHeight,
        final int rvWidth, final int rvHeight, boolean concatenateInfo) {

    if (observer == null) {
        return null;
    }

    synchronized (ObserverCache.INSTANCE) {
        ImageObserver o = (ImageObserver) ObserverCache.INSTANCE.get(observer);

        if (o == null) {

            o = (Image resolutionVariant, int flags,
                    int x, int y, int width, int height) -> {

                        if ((flags & (ImageObserver.WIDTH | BITS_INFO)) != 0) {
                            width = (width + 1) / 2;
                        }

                        if ((flags & (ImageObserver.HEIGHT | BITS_INFO)) != 0) {
                            height = (height + 1) / 2;
                        }

                        if ((flags & BITS_INFO) != 0) {
                            x /= 2;
                            y /= 2;
                        }

                        if(concatenateInfo){
                            flags &= ((ToolkitImage) image).
                                    getImageRep().check(null);
                        }

                        return observer.imageUpdate(
                                image, flags, x, y, width, height);
                    };

            ObserverCache.INSTANCE.put(observer, o);
        }
        return o;
    }
}
 

public boolean imageUpdate(Image img, int flags, int x, int y,
                           int newWidth, int newHeight ) {
    if (img != image && img != disabledImage ||
        image == null || getParent() == null) {

        return false;
    }

    // Bail out if there was an error:
    if ((flags & (ABORT|ERROR)) != 0) {
        repaint(0);
        synchronized(ImageView.this) {
            if (image == img) {
                // Be sure image hasn't changed since we don't
                // initialy synchronize
                image = null;
                if ((state & WIDTH_FLAG) != WIDTH_FLAG) {
                    width = DEFAULT_WIDTH;
                }
                if ((state & HEIGHT_FLAG) != HEIGHT_FLAG) {
                    height = DEFAULT_HEIGHT;
                }
            } else {
                disabledImage = null;
            }
            if ((state & LOADING_FLAG) == LOADING_FLAG) {
                // No need to resize or repaint, still in the process
                // of loading.
                return false;
            }
        }
        updateAltTextView();
        safePreferenceChanged();
        return false;
    }

    if (image == img) {
        // Resize image if necessary:
        short changed = 0;
        if ((flags & ImageObserver.HEIGHT) != 0 && !getElement().
              getAttributes().isDefined(HTML.Attribute.HEIGHT)) {
            changed |= 1;
        }
        if ((flags & ImageObserver.WIDTH) != 0 && !getElement().
              getAttributes().isDefined(HTML.Attribute.WIDTH)) {
            changed |= 2;
        }

        synchronized(ImageView.this) {
            if ((changed & 1) == 1 && (state & WIDTH_FLAG) == 0) {
                width = newWidth;
            }
            if ((changed & 2) == 2 && (state & HEIGHT_FLAG) == 0) {
                height = newHeight;
            }
            if ((state & LOADING_FLAG) == LOADING_FLAG) {
                // No need to resize or repaint, still in the process of
                // loading.
                return true;
            }
        }
        if (changed != 0) {
            // May need to resize myself, asynchronously:
            safePreferenceChanged();
            return true;
        }
    }

    // Repaint when done or when new pixels arrive:
    if ((flags & (FRAMEBITS|ALLBITS)) != 0) {
        repaint(0);
    }
    else if ((flags & SOMEBITS) != 0 && sIsInc) {
        repaint(sIncRate);
    }
    return ((flags & ALLBITS) == 0);
}