Examples of javax.media.jai.util.ImagingListener

javax.media.jai.util.ImagingListener
An ImagingListener has the capability to report the abnormal situations in the image processing procedures. The concrete class either holds the reported information and processes it, or passes them to other processing or logging mechanisms.
A default ImagingListener resides in an instance of JAI (by calling the method setImagingListener), and can be retrieved by calling the method getImagingListener. This listener should not propagate the Throwable reported from an OperationRegistry. Otherwise, it may break the loop through the image factories. The typical JAI to be used will be the default JAI instance.
An ImagingListener can also be attached to a rendering node as a rendering hint with a key JAI.KEY_IMAGING_LISTENER. This listener can monitor errors occurring in the rendering process. The default value for this rendering hint is the listener registered to the default JAI instance.
The typical situations where ImagingListener objects can be called are: (1) The create method of a concrete RenderedImageFactory or ContextualRenderedImageFactory. (2) The rendering of the node. For the latter case, the I/O, network, and arithmetic problems will be reported.
When errors are encountered in user-written operations, those operations have two choices. The typical choice will be to simply throw an exception and let the JAI framework call errorOccurred. However, it is also acceptable to obtain the proper ImagingListener and call errorOccurred directly. This might be useful if for example special retry options were available to the user operation. Care should be taken in this case to avoid an infinite retry loop.
For backward compatibility, an instance of a simple implementation of this interface is used as the default in all the JAI instances. It re-throws the Throwable if it is a RuntimeException. For the other types of Throwable, it only prints the message and the stack trace to the stream System.err, and returns false. To process the reported errors or warnings an alternate implementation of ImagingListener should be written.

The provided Throwable, its cause, or its root cause may be re-thrown directly, or wrapped into a subclass of RuntimeException and thrown if this listener cannot handle it properly, in which case the Throwable will be propogated back to the calling application.
In the JAI 1.1.2 implementation from Sun, when the method errorOccurred is called, the parameter isRetryable is always false; future implementations may activate retry capability.
@since JAI 1.1.2

/*      */ 
/* 1074 */     return fontRenderContext;
/*      */   }
/*      */ 
/*      */   void sendExceptionToListener(String message, Exception e) {
/* 1078 */     ImagingListener listener = null;
/* 1079 */     if (this.renderingHints != null) {
/* 1080 */       listener = (ImagingListener)this.renderingHints.get(JAI.KEY_IMAGING_LISTENER);
/*      */     }
/*      */ 
/* 1083 */     if (listener == null)
/* 1084 */       listener = JAI.getDefaultInstance().getImagingListener();
/* 1085 */     listener.errorOccurred(message, e, this, false);
/*      */   }

View Full Code Here

/*     */       {
/* 161 */         if ((rendering instanceof RenderedOp)) {
/*     */           try {
/* 163 */             rendering = ((RenderedOp)rendering).getRendering();
/*     */           } catch (Exception e) {
/* 165 */             ImagingListener listener = ImageUtil.getImagingListener(renderHints);
/*     */ 
/* 167 */             String message = JaiI18N.getString("CRIFImpl0") + this.operationName;
/*     */ 
/* 169 */             listener.errorOccurred(message, e, this, false);
/*     */           }
/*     */         }
/*     */ 
/* 173 */         return rendering;
/*     */       }

View Full Code Here

/*     */ public class FileLoadRIF
/*     */   implements RenderedImageFactory
/*     */ {
/*     */   public RenderedImage create(ParameterBlock args, RenderingHints hints)
/*     */   {
/*  91 */     ImagingListener listener = ImageUtil.getImagingListener(hints);
/*     */     try
/*     */     {
/*  95 */       String fileName = (String)args.getObjectParameter(0);
/*  96 */       SeekableStream src = new FileSeekableStream(fileName);
/*     */ 
/*  98 */       ImageDecodeParam param = null;
/*  99 */       if (args.getNumParameters() > 1) {
/* 100 */         param = (ImageDecodeParam)args.getObjectParameter(1);
/*     */       }
/*     */ 
/* 103 */       ParameterBlock newArgs = new ParameterBlock();
/* 104 */       newArgs.add(src);
/* 105 */       newArgs.add(param);
/*     */ 
/* 107 */       RenderingHints.Key key = JAI.KEY_OPERATION_BOUND;
/* 108 */       int bound = 2;
/* 109 */       if (hints == null) {
/* 110 */         hints = new RenderingHints(key, new Integer(bound));
/* 111 */       } else if (!hints.containsKey(key)) {
/* 112 */         hints = (RenderingHints)hints.clone();
/* 113 */         hints.put(key, new Integer(bound));
/*     */       }
/*     */ 
/* 118 */       OperationRegistry registry = (OperationRegistry)hints.get(JAI.KEY_OPERATION_REGISTRY);
/*     */ 
/* 122 */       RenderedImage image = RIFRegistry.create(registry, "stream", newArgs, hints);
/*     */ 
/* 125 */       return image == null ? null : new StreamImage(image, src);
/*     */     }
/*     */     catch (FileNotFoundException e) {
/* 128 */       String message = JaiI18N.getString("FileLoadRIF0") + args.getObjectParameter(0);
/*     */ 
/* 130 */       listener.errorOccurred(message, e, this, false);
/*     */ 
/* 132 */       return null;
/*     */     } catch (Exception e) {
/* 134 */       String message = JaiI18N.getString("FileLoadRIF1");
/* 135 */       listener.errorOccurred(message, e, this, false);
/*     */     }
/* 137 */     return null;
/*     */   }

View Full Code Here

/*      */ 
/* 1114 */     return ti;
/*      */   }
/*      */ 
/*      */   void sendExceptionToListener(String message, Exception e) {
/* 1118 */     ImagingListener listener = null;
/* 1119 */     if (this.renderingHints != null) {
/* 1120 */       listener = (ImagingListener)this.renderingHints.get(JAI.KEY_IMAGING_LISTENER);
/*      */     }
/*      */ 
/* 1123 */     if (listener == null)
/* 1124 */       listener = JAI.getDefaultInstance().getImagingListener();
/* 1125 */     listener.errorOccurred(message, e, this, false);
/*      */   }

View Full Code Here

/*  553 */     if (((serverMask & 0x15) != 21) && ((serverMask & 0x2A) != 42) && ((serverMask & 0x5) != 5) && ((serverMask & 0xA) != 10))
/*      */     {
/*  557 */       return null;
/*      */     }
/*      */ 
/*  560 */     ImagingListener listener = ImageUtil.getImagingListener(renderContext);
/*      */ 
/*  563 */     boolean isJPEG = false;
/*  564 */     boolean isFull = false;
/*  565 */     if ((serverMask & 0x15) == 21) {
/*  566 */       isJPEG = isFull = 1;
/*  567 */     } else if ((serverMask & 0x2A) == 42) {
/*  568 */       isJPEG = false;
/*  569 */       isFull = true;
/*  570 */     } else if ((serverMask & 0x5) == 5) {
/*  571 */       isJPEG = true;
/*  572 */       isFull = false;
/*      */     }
/*      */ 
/*  576 */     StringBuffer buf = new StringBuffer((String)paramBlock.getObjectParameter(0));
/*      */ 
/*  581 */     if ((opMask & 0x1) != 0) {
/*  582 */       buf.append("&FTR=" + paramBlock.getFloatParameter(2));
/*      */     }
/*      */ 
/*  586 */     if ((opMask & 0x2) != 0) {
/*  587 */       buf.append("&CTW=");
/*  588 */       float[] ctw = (float[])paramBlock.getObjectParameter(3);
/*  589 */       for (int i = 0; i < ctw.length; i++) {
/*  590 */         buf.append(ctw[i]);
/*  591 */         if (i != ctw.length - 1) {
/*  592 */           buf.append(",");
/*      */         }
/*      */       }
/*      */ 
/*      */     }
/*      */ 
/*  598 */     if ((opMask & 0x4) != 0) {
/*  599 */       buf.append("&CNT=" + paramBlock.getFloatParameter(4));
/*      */     }
/*      */ 
/*  603 */     if ((opMask & 0x8) != 0) {
/*  604 */       Rectangle2D roi = (Rectangle2D)paramBlock.getObjectParameter(5);
/*      */ 
/*  606 */       buf.append("&ROI=" + roi.getX() + "," + roi.getY() + "," + roi.getWidth() + "," + roi.getHeight());
/*      */     }
/*      */ 
/*  622 */     AffineTransform postTransform = new AffineTransform();
/*      */ 
/*  625 */     AffineTransform at = (AffineTransform)renderContext.getTransform().clone();
/*      */ 
/*  629 */     if ((at.getTranslateX() != 0.0D) || (at.getTranslateY() != 0.0D)) {
/*  630 */       postTransform.setToTranslation(at.getTranslateX(), at.getTranslateY());
/*      */ 
/*  632 */       double[] m = new double[6];
/*  633 */       at.getMatrix(m);
/*  634 */       at.setTransform(m[0], m[1], m[2], m[3], 0.0D, 0.0D);
/*      */     }
/*      */ 
/*  638 */     Rectangle2D rgn = null;
/*  639 */     if ((opMask & 0x40) != 0) {
/*  640 */       rgn = (Rectangle2D)paramBlock.getObjectParameter(8);
/*      */     } else {
/*  642 */       float aspectRatio = 1.0F;
/*  643 */       if ((opMask & 0x20) != 0)
/*  644 */         aspectRatio = paramBlock.getFloatParameter(7);
/*      */       else {
/*  646 */         aspectRatio = ((Float)lowRes.getProperty("aspect-ratio")).floatValue();
/*      */       }
/*      */ 
/*  649 */       rgn = new Rectangle2D.Float(0.0F, 0.0F, aspectRatio, 1.0F);
/*      */     }
/*      */ 
/*  654 */     Rectangle dstROI = at.createTransformedShape(rgn).getBounds();
/*      */ 
/*  658 */     AffineTransform scale = AffineTransform.getScaleInstance(dstROI.getWidth() / rgn.getWidth(), dstROI.getHeight() / rgn.getHeight());
/*      */     try
/*      */     {
/*  666 */       at.preConcatenate(scale.createInverse());
/*      */     } catch (Exception e) {
/*  668 */       String message = JaiI18N.getString("IIPCRIF6");
/*  669 */       listener.errorOccurred(message, new ImagingException(message, e), this, false);
/*      */     }
/*      */ 
/*  677 */     AffineTransform afn = (AffineTransform)paramBlock.getObjectParameter(6);
/*      */     try
/*      */     {
/*  680 */       afn.preConcatenate(at.createInverse());
/*      */     } catch (Exception e) {
/*  682 */       String message = JaiI18N.getString("IIPCRIF6");
/*  683 */       listener.errorOccurred(message, new ImagingException(message, e), this, false);
/*      */     }
/*      */ 
/*  689 */     if (isFull)
/*      */     {
/*  692 */       buf.append("&WID=" + dstROI.width + "&HEI=" + dstROI.height);
/*      */     }
/*      */ 
/*  729 */     double[] matrix = new double[6];
/*  730 */     afn.getMatrix(matrix);
/*  731 */     buf.append("&AFN=" + matrix[0] + "," + matrix[2] + ",0," + matrix[4] + "," + matrix[1] + "," + matrix[3] + ",0," + matrix[5] + ",0,0,1,0,0,0,0,1");
/*      */ 
/*  737 */     if ((opMask & 0x20) != 0) {
/*  738 */       buf.append("&RAR=" + paramBlock.getFloatParameter(7));
/*      */     }
/*      */ 
/*  742 */     if ((opMask & 0x40) != 0) {
/*  743 */       Rectangle2D dstRGN = (Rectangle2D)paramBlock.getObjectParameter(8);
/*      */ 
/*  745 */       buf.append("&RGN=" + dstRGN.getX() + "," + dstRGN.getY() + "," + dstRGN.getWidth() + "," + dstRGN.getHeight());
/*      */     }
/*      */ 
/*  750 */     if ((isFull) && (
/*  751 */       ((opMask & 0x80) != 0) || ((opMask & 0x100) != 0)))
/*      */     {
/*  753 */       buf.append("&RFM=" + paramBlock.getIntParameter(9));
/*  754 */       if ((opMask & 0x100) != 0) {
/*  755 */         String axis = (String)paramBlock.getObjectParameter(10);
/*  756 */         if (axis.equalsIgnoreCase("x"))
/*  757 */           buf.append(",0");
/*      */         else {
/*  759 */           buf.append(",90");
/*      */         }
/*      */ 
/*      */       }
/*      */ 
/*      */     }
/*      */ 
/*  766 */     if (((opMask & 0x200) == 0) || 
/*  774 */       (isJPEG)) {
/*  775 */       if ((opMask & 0x400) != 0) {
/*  776 */         buf.append("&QLT=" + paramBlock.getIntParameter(12));
/*      */       }
/*      */ 
/*  779 */       if ((opMask & 0x800) != 0) {
/*  780 */         buf.append("&CIN=" + paramBlock.getIntParameter(13));
/*      */       }
/*      */ 
/*      */     }
/*      */ 
/*  785 */     String format = isJPEG ? "JPEG" : "FPX";
/*      */ 
/*  788 */     buf.append("&CVT=" + format);
/*      */ 
/*  792 */     InputStream stream = null;
/*  793 */     RenderedImage rendering = null;
/*      */     try {
/*  795 */       URL url = new URL(buf.toString());
/*  796 */       stream = url.openStream();
/*  797 */       MemoryCacheSeekableStream sStream = new MemoryCacheSeekableStream(stream);
/*      */ 
/*  799 */       rendering = JAI.create(format, sStream);
/*      */     } catch (Exception e) {
/*  801 */       String message = JaiI18N.getString("IIPCRIF7") + " " + buf.toString();
/*      */ 
/*  803 */       listener.errorOccurred(message, new ImagingException(message, e), this, false);
/*      */     }
/*      */ 
/*  810 */     if (!isFull) {
/*  811 */       postTransform.scale(dstROI.getWidth() / rendering.getWidth(), dstROI.getHeight() / rendering.getHeight());
/*      */     }

View Full Code Here

/*      */   private RenderedImage clientProc(RenderContext renderContext, ParameterBlock paramBlock, int opMask, RenderedImage lowRes)
/*      */   {
/*  838 */     AffineTransform at = renderContext.getTransform();
/*  839 */     RenderingHints hints = renderContext.getRenderingHints();
/*      */ 
/*  841 */     ImagingListener listener = ImageUtil.getImagingListener(renderContext);
/*      */ 
/*  844 */     int[] maxSize = (int[])lowRes.getProperty("max-size");
/*  845 */     int maxWidth = maxSize[0];
/*  846 */     int maxHeight = maxSize[1];
/*  847 */     int numLevels = ((Integer)lowRes.getProperty("resolution-number")).intValue();
/*      */ 
/*  851 */     float aspectRatioSource = maxWidth / maxHeight;
/*  852 */     float aspectRatio = (opMask & 0x20) != 0 ? paramBlock.getFloatParameter(7) : aspectRatioSource;
/*      */ 
/*  856 */     Rectangle2D bounds2D = new Rectangle2D.Float(0.0F, 0.0F, aspectRatio, 1.0F);
/*      */     int height;
/*  862 */     if (at.isIdentity()) {
/*  863 */       AffineTransform afn = (AffineTransform)paramBlock.getObjectParameter(6);
/*      */ 
/*  865 */       Rectangle2D bounds = afn.createTransformedShape(bounds2D).getBounds2D();
/*      */ 
/*  867 */       double H = maxHeight * bounds.getHeight();
/*  868 */       double W = maxHeight * bounds.getWidth();
/*  869 */       double m = Math.max(H, W / aspectRatioSource);
/*  870 */       int height = (int)(m + 0.5D);
/*  871 */       int width = (int)(aspectRatioSource * m + 0.5D);
/*  872 */       at = AffineTransform.getScaleInstance(width, height);
/*  873 */       renderContext = (RenderContext)renderContext.clone();
/*  874 */       renderContext.setTransform(at);
/*      */     } else {
/*  876 */       Rectangle bounds = at.createTransformedShape(bounds2D).getBounds();
/*  877 */       int width = bounds.width;
/*  878 */       height = bounds.height;
/*      */     }
/*      */ 
/*  882 */     int res = numLevels - 1;
/*  883 */     int hRes = maxHeight;
/*  884 */     while (res > 0) {
/*  885 */       hRes = (int)((hRes + 1.0F) / 2.0F);
/*  886 */       if (hRes < height) {
/*      */         break;
/*      */       }
/*  889 */       res--;
/*      */     }
/*      */ 
/*  893 */     int[] subImageArray = (int[])paramBlock.getObjectParameter(1);
/*  894 */     int subImage = subImageArray.length < res + 1 ? 0 : subImageArray[res];
/*  895 */     if (subImage < 0) {
/*  896 */       subImage = 0;
/*      */     }
/*  898 */     ParameterBlock pb = new ParameterBlock();
/*  899 */     pb.add(paramBlock.getObjectParameter(0)).add(res).add(subImage);
/*  900 */     RenderedImage iipRes = JAI.create("iipresolution", pb);
/*  901 */     Vector sources = new Vector(1);
/*  902 */     sources.add(iipRes);
/*  903 */     RenderableImage ri = new MultiResolutionRenderableImage(sources, 0.0F, 0.0F, 1.0F);
/*      */ 
/*  908 */     if ((opMask & 0x1) != 0) {
/*  909 */       float filter = paramBlock.getFloatParameter(2);
/*  910 */       pb = new ParameterBlock().addSource(ri).add(filter);
/*  911 */       ri = new RenderableImageOp(new FilterCRIF(), pb);
/*      */     }
/*      */ 
/*  918 */     int nBands = iipRes.getSampleModel().getNumBands();
/*  919 */     if ((opMask & 0x2) != 0) {
/*  920 */       double[][] ctw = getColorTwistMatrix(iipRes.getColorModel(), paramBlock);
/*      */ 
/*  922 */       pb = new ParameterBlock().addSource(ri).add(ctw);
/*  923 */       ri = JAI.createRenderable("bandcombine", pb);
/*  924 */       nBands = ctw.length;
/*      */     }
/*      */ 
/*  928 */     if ((opMask & 0x4) != 0) {
/*  929 */       int csType = iipRes.getColorModel().getColorSpace().getType();
/*  930 */       boolean isPYCC = (csType != 6) && (csType != 5);
/*      */ 
/*  934 */       if (isPYCC)
/*      */       {
/*      */         double[][] matrix;
/*      */         double[][] matrix;
/*  936 */         if (nBands == 3)
/*  937 */           matrix = composeMatrices(YCC_TO_RGB, YCC_TO_RGB_CONST);
/*      */         else {
/*  939 */           matrix = composeMatrices(YCCA_TO_RGBA, YCCA_TO_RGBA_CONST);
/*      */         }
/*  941 */         pb = new ParameterBlock().addSource(ri).add(matrix);
/*  942 */         ri = JAI.createRenderable("bandcombine", pb);
/*      */       }
/*      */ 
/*  945 */       float contrast = paramBlock.getFloatParameter(4);
/*  946 */       LookupTableJAI lut = createContrastLUT(contrast, nBands);
/*      */ 
/*  948 */       pb = new ParameterBlock().addSource(ri).add(lut);
/*  949 */       ri = JAI.createRenderable("lookup", pb);
/*      */ 
/*  951 */       if (isPYCC)
/*      */       {
/*      */         double[][] matrix;
/*      */         double[][] matrix;
/*  953 */         if (nBands == 3)
/*  954 */           matrix = composeMatrices(RGB_TO_YCC, RGB_TO_YCC_CONST);
/*      */         else {
/*  956 */           matrix = composeMatrices(RGBA_TO_YCCA, RGBA_TO_YCCA_CONST);
/*      */         }
/*  958 */         pb = new ParameterBlock().addSource(ri).add(matrix);
/*  959 */         ri = JAI.createRenderable("bandcombine", pb);
/*      */       }
/*      */ 
/*      */     }
/*      */ 
/*  964 */     if ((opMask & 0x8) != 0)
/*      */     {
/*  966 */       Rectangle2D rect = (Rectangle2D)paramBlock.getObjectParameter(5);
/*      */ 
/*  969 */       if (!rect.intersects(0.0D, 0.0D, aspectRatioSource, 1.0D)) {
/*  970 */         throw new RuntimeException(JaiI18N.getString("IIPCRIF5"));
/*      */       }
/*      */ 
/*  974 */       Rectangle2D rectS = new Rectangle2D.Float(0.0F, 0.0F, aspectRatioSource, 1.0F);
/*      */ 
/*  978 */       if (!rect.equals(rectS))
/*      */       {
/*  980 */         rect = rect.createIntersection(rectS);
/*      */ 
/*  983 */         pb = new ParameterBlock().addSource(ri);
/*  984 */         pb.add((float)rect.getMinX()).add((float)rect.getMinY());
/*  985 */         pb.add((float)rect.getWidth()).add((float)rect.getHeight());
/*  986 */         ri = JAI.createRenderable("crop", pb);
/*      */       }
/*      */ 
/*      */     }
/*      */ 
/*  999 */     if ((opMask & 0x10) != 0) {
/* 1000 */       AffineTransform afn = (AffineTransform)paramBlock.getObjectParameter(6);
/*      */       try
/*      */       {
/* 1004 */         afn = afn.createInverse();
/*      */       }
/*      */       catch (NoninvertibleTransformException e) {
/* 1007 */         listener.errorOccurred(JaiI18N.getString("AffineNotInvertible"), e, this, false);
/*      */       }
/*      */ 
/* 1011 */       pb = new ParameterBlock().addSource(ri).add(afn);
/* 1012 */       if ((hints != null) && (hints.containsKey(JAI.KEY_INTERPOLATION))) {
/* 1013 */         pb.add(hints.get(JAI.KEY_INTERPOLATION));

View Full Code Here

/*      */ 
/*      */   public RenderedImage create(RenderContext renderContext, ParameterBlock paramBlock)
/*      */   {
/* 1070 */     int opMask = getOperationMask(paramBlock);
/*      */ 
/* 1072 */     ImagingListener listener = ImageUtil.getImagingListener(renderContext);
/*      */ 
/* 1075 */     ParameterBlock pb = new ParameterBlock();
/* 1076 */     int[] subImageArray = (int[])paramBlock.getObjectParameter(1);
/* 1077 */     pb.add(paramBlock.getObjectParameter(0)).add(0).add(subImageArray[0]);
/* 1078 */     RenderedImage lowRes = JAI.create("iipresolution", pb);
/*      */ 
/* 1081 */     int serverMask = getServerCapabilityMask((String)paramBlock.getObjectParameter(0), lowRes);
/*      */ 
/* 1085 */     RenderedImage rendering = null;
/*      */ 
/* 1088 */     if (((serverMask & 0x15) == 21) || ((serverMask & 0x2A) == 42) || ((serverMask & 0x5) == 5) || ((serverMask & 0xA) == 10))
/*      */     {
/* 1093 */       rendering = serverProc(serverMask, renderContext, paramBlock, opMask, lowRes);
/*      */     }
/*      */     else
/*      */     {
/* 1097 */       rendering = clientProc(renderContext, paramBlock, opMask, lowRes);
/*      */ 
/* 1101 */       if ((opMask & 0x8) != 0)
/*      */       {
/* 1103 */         Rectangle2D rgn = (Rectangle2D)paramBlock.getObjectParameter(5);
/*      */ 
/* 1107 */         AffineTransform at = (AffineTransform)((AffineTransform)paramBlock.getObjectParameter(6)).clone();
/*      */ 
/* 1111 */         if (!at.isIdentity()) {
/*      */           try {
/* 1113 */             at = at.createInverse();
/*      */           } catch (Exception e) {
/* 1115 */             String message = JaiI18N.getString("IIPCRIF6");
/* 1116 */             listener.errorOccurred(message, new ImagingException(message, e), this, false);
/*      */           }
/*      */ 
/*      */         }
/*      */ 
/* 1128 */         at.preConcatenate(renderContext.getTransform());

View Full Code Here

/* 1328 */       ((RemoteRenderedImage)this.theImage).setServerNegotiatedValues(negotiatedValues);
/*      */   }
/*      */ 
/*      */   void sendExceptionToListener(String message, Exception e)
/*      */   {
/* 1334 */     ImagingListener listener = (ImagingListener)getRenderingHints().get(JAI.KEY_IMAGING_LISTENER);
/*      */ 
/* 1337 */     listener.errorOccurred(message, e, this, false);
/*      */   }

View Full Code Here

/*     */     }
/* 552 */     return null;
/*     */   }
/*     */ 
/*     */   void sendExceptionToListener(String message, Exception e) {
/* 556 */     ImagingListener listener = JAI.getDefaultInstance().getImagingListener();
/* 557 */     listener.errorOccurred(message, e, this, false);
/*     */   }

View Full Code Here

/* 975 */       this.clientCapabilities = rrif.getClientCapabilities();
/*     */     }
/*     */   }
/*     */ 
/*     */   void sendExceptionToListener(Exception e) {
/* 980 */     ImagingListener listener = null;
/* 981 */     if (this.hints != null)
/* 982 */       listener = (ImagingListener)this.hints.get(JAI.KEY_IMAGING_LISTENER);
/*     */     else
/* 984 */       listener = JAI.getDefaultInstance().getImagingListener();
/* 985 */     String message = JaiI18N.getString("PlanarImageServerProxy2");
/* 986 */     listener.errorOccurred(message, new RemoteImagingException(message, e), this, false);
/*     */   }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of javax.media.jai.util.ImagingListener

com.sun.media.jai.codecimpl.util.ImageUtil

com.sun.media.jai.codecimpl.util.SunTileCache

com.sun.media.jai.codecimpl.util.SunTileScheduler

com.sun.media.jai.mlib.MediaLibAccessor

com.sun.media.jai.mlib.MlibHistogramRIF

com.sun.media.jai.opimage.CodecRIFUtil

com.sun.media.jai.opimage.EncodeRIF

com.sun.media.jai.opimage.FileLoadRIF

com.sun.media.jai.opimage.FileStoreRIF

com.sun.media.jai.opimage.HistogramRIF

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.