/// <summary>
        /// Change the current ParameterBlock of the operation, allowing
        /// editing of image rendering chains.  The effects of such a
        /// change will be visible when a new rendering is created from
        /// this RenderableImageOp or any dependent RenderableImageOp.
        /// </summary>
        /// <param name="paramBlock"> the new ParameterBlock. </param>
        /// <returns> the old ParameterBlock. </returns>
        /// <seealso cref= #getParameterBlock </seealso>
        public virtual ParameterBlock SetParameterBlock(ParameterBlock paramBlock)
        {
            ParameterBlock oldParamBlock = this.ParamBlock;

            this.ParamBlock = (ParameterBlock)paramBlock.Clone();
            return(oldParamBlock);
        }
        /// <summary>
        /// Creates a RenderedImage which represents this
        /// RenderableImageOp (including its Renderable sources) rendered
        /// according to the given RenderContext.
        ///
        /// <para> This method supports chaining of either Renderable or
        /// RenderedImage operations.  If sources in
        /// the ParameterBlock used to construct the RenderableImageOp are
        /// RenderableImages, then a three step process is followed:
        ///
        /// <ol>
        /// <li> mapRenderContext() is called on the associated CRIF for
        /// each RenderableImage source;
        /// <li> createRendering() is called on each of the RenderableImage sources
        /// using the backwards-mapped RenderContexts obtained in step 1,
        /// resulting in a rendering of each source;
        /// <li> ContextualRenderedImageFactory.create() is called
        /// with a new ParameterBlock containing the parameters of
        /// the RenderableImageOp and the RenderedImages that were created by the
        /// createRendering() calls.
        /// </ol>
        ///
        /// </para>
        /// <para> If the elements of the source Vector of
        /// the ParameterBlock used to construct the RenderableImageOp are
        /// instances of RenderedImage, then the CRIF.create() method is
        /// called immediately using the original ParameterBlock.
        /// This provides a basis case for the recursion.
        ///
        /// </para>
        /// <para> The created RenderedImage may have a property identified
        /// by the String HINTS_OBSERVED to indicate which RenderingHints
        /// (from the RenderContext) were used to create the image.
        /// In addition any RenderedImages
        /// that are obtained via the getSources() method on the created
        /// RenderedImage may have such a property.
        ///
        /// </para>
        /// </summary>
        /// <param name="renderContext"> The RenderContext to use to perform the rendering. </param>
        /// <returns> a RenderedImage containing the desired output image. </returns>
        public virtual RenderedImage CreateRendering(RenderContext renderContext)
        {
            RenderedImage image = null;
            RenderContext rcOut = null;

            // Clone the original ParameterBlock; if the ParameterBlock
            // contains RenderableImage sources, they will be replaced by
            // RenderedImages.
            ParameterBlock renderedParamBlock = (ParameterBlock)ParamBlock.Clone();
            ArrayList      sources            = RenderableSources;

            try
            {
                // This assumes that if there is no renderable source, that there
                // is a rendered source in paramBlock

                if (sources != null)
                {
                    ArrayList renderedSources = new ArrayList();
                    for (int i = 0; i < sources.Count; i++)
                    {
                        rcOut = MyCRIF.MapRenderContext(i, renderContext, ParamBlock, this);
                        RenderedImage rdrdImage = ((RenderableImage)sources[i]).CreateRendering(rcOut);
                        if (rdrdImage == null)
                        {
                            return(null);
                        }

                        // Add this rendered image to the ParameterBlock's
                        // list of RenderedImages.
                        renderedSources.Add(rdrdImage);
                    }

                    if (renderedSources.Count > 0)
                    {
                        renderedParamBlock.Sources = renderedSources;
                    }
                }

                return(MyCRIF.Create(renderContext, renderedParamBlock));
            }
            catch (ArrayIndexOutOfBoundsException)
            {
                // This should never happen
                return(null);
            }
        }
 /// <summary>
 /// Constructs a RenderedImageOp given a
 /// ContextualRenderedImageFactory object, and
 /// a ParameterBlock containing RenderableImage sources and other
 /// parameters.  Any RenderedImage sources referenced by the
 /// ParameterBlock will be ignored.
 /// </summary>
 /// <param name="CRIF"> a ContextualRenderedImageFactory object </param>
 /// <param name="paramBlock"> a ParameterBlock containing this operation's source
 ///        images and other parameters necessary for the operation
 ///        to run. </param>
 public RenderableImageOp(ContextualRenderedImageFactory CRIF, ParameterBlock paramBlock)
 {
     this.MyCRIF     = CRIF;
     this.ParamBlock = (ParameterBlock)paramBlock.Clone();
 }