## javax.media.jai
Class OperationDescriptorImpl

    java.lang.Object
      |
      +--javax.media.jai.OperationDescriptorImpl

All Implemented Interfaces:
  OperationDescriptor, RegistryElementDescriptor, java.io.Serializable

Direct Known Subclasses:
  AbsoluteDescriptor, AddCollectionDescriptor, AddConstDescriptor, AddConstToCollectionDescriptor, AddDescriptor, AffineDescriptor, AndConstDescriptor, AndDescriptor, AWTImageDescriptor, BandCombineDescriptor, BandMergeDescriptor, BandSelectDescriptor, BinarizeDescriptor, BMPDescriptor, BorderDescriptor, BoxFilterDescriptor, ClampDescriptor, ColorConvertDescriptor, CompositeDescriptor, ConjugateDescriptor, ConstantDescriptor, ConvolveDescriptor, CropDescriptor, DCTDescriptor, DFTDescriptor, DilateDescriptor, DivideByConstDescriptor, DivideComplexDescriptor, DivideDescriptor, DivideIntoConstDescriptor, EncodeDescriptor, ErodeDescriptor, ErrorDiffusionDescriptor, ExpDescriptor, ExtremaDescriptor, FileLoadDescriptor, FileStoreDescriptor, FilteredSubsampleDescriptor, FormatDescriptor, FPXDescriptor, GIFDescriptor, GradientMagnitudeDescriptor, HistogramDescriptor, IDCTDescriptor, IDFTDescriptor, IIPDescriptor, IIPResolutionDescriptor, ImageFunctionDescriptor, InvertDescriptor, JPEGDescriptor, LogDescriptor, LookupDescriptor, MagnitudeDescriptor, MagnitudeSquaredDescriptor, MatchCDFDescriptor, MaxDescriptor, MaxFilterDescriptor, MeanDescriptor, MedianFilterDescriptor, MinDescriptor, MinFilterDescriptor, MultiplyComplexDescriptor, MultiplyConstDescriptor, MultiplyDescriptor, NotDescriptor, NullDescriptor, OrConstDescriptor, OrderedDitherDescriptor, OrDescriptor, OverlayDescriptor, PatternDescriptor, PeriodicShiftDescriptor, PhaseDescriptor, PiecewiseDescriptor, PNGDescriptor, PNMDescriptor, PolarToComplexDescriptor, RenderableDescriptor, RescaleDescriptor, RotateDescriptor, ScaleDescriptor, ShearDescriptor, StreamDescriptor, SubsampleBinaryToGrayDescriptor, SubtractConstDescriptor, SubtractDescriptor, SubtractFromConstDescriptor, ThresholdDescriptor, TIFFDescriptor, TranslateDescriptor, TransposeDescriptor, UnsharpMaskDescriptor, URLDescriptor, WarpDescriptor, XorConstDescriptor, XorDescriptor

public abstract class OperationDescriptorImpl
extends java.lang.Object
implements OperationDescriptor, java.io.Serializable

This class provides an abstract implementation of the `OperationDescriptor` interface that is suitable for subclassing.

See Also:
  `OperationDescriptor`, `RegistryElementDescriptor`, Serialized Form

Field Summary
`protected java.lang.String[][]` `resources` The resource tags and their corresponding data, stored as an two-dimensional `String` array.
`protected java.lang.String[]` `sourceNames` An array of `String`s that are the names of the sources of this operation.
`protected java.lang.String[]` `supportedModes` An array of operation modes supported by this operator.

Fields inherited from interface javax.media.jai.OperationDescriptor
`NO_PARAMETER_DEFAULT`

Constructor Summary
`OperationDescriptorImpl(java.lang.String[][] resources, java.lang.Class[] sourceClasses)` Deprecated. since JAI 1.1 in favor of constructors where the mode specfic information is explicitly specified.
`OperationDescriptorImpl(java.lang.String[][] resources, java.lang.Class[] sourceClasses, java.lang.Class[] renderableSourceClasses)` Deprecated. since JAI 1.1 in favor of constructors where the mode specfic information is explicitly specified.

`OperationDescriptorImpl(java.lang.String[][] resources, java.lang.Class[] sourceClasses, java.lang.Class[] renderableSourceClasses, java.lang.Class[] paramClasses, java.lang.String[] paramNames, java.lang.Object[] paramDefaults)`
Deprecated. as of Java(tm) Advanced Imaging 1.1 in favor of constructors where supported modes are explicitly specified. Uses `isRenderedSupported()` and `isRenderableSupported()` to figure out the supported modes.

`OperationDescriptorImpl(java.lang.String[][] resources, java.lang.Class[] paramClasses, java.lang.String[] paramNames, java.lang.Object[] paramDefaults)` Deprecated. since JAI 1.1 in favor of constructors where the mode specfic information is explicitly specified.
`OperationDescriptorImpl(java.lang.String[][] resources, int numSources)` Deprecated. since JAI 1.1 in favor of constructors where the mode specfic information is explicitly specified.
`OperationDescriptorImpl(java.lang.String[][] resources, int numSources, java.lang.Class[] paramClasses, java.lang.String[] paramNames, java.lang.Object[] paramDefaults)` Deprecated. as of Java(tm) Advanced Imaging 1.1 in favor of constructors where supported modes are explicitly specified. Uses `isRenderedSupported()` and `isRenderableSupported()` to figure out the supported modes.
`OperationDescriptorImpl(java.lang.String[][] resources, java.lang.String[] supportedModes, int numSources, java.lang.String[] paramNames, java.lang.Class[] paramClasses, java.lang.Object[] paramDefaults, java.lang.Object[] validParamValues)` Constructor.
`OperationDescriptorImpl(java.lang.String[][] resources, java.lang.String[] supportedModes, java.lang.String[] sourceNames, java.lang.Class[][] sourceClasses, ParameterListDescriptor pld)` Constructor.
`OperationDescriptorImpl(java.lang.String[][] resources, java.lang.String[] supportedModes, java.lang.String[] sourceNames, java.lang.Class[][] sourceClasses, ParameterListDescriptor[] pld)` Constructor which accepts a `ParameterListDescriptor` to describe the parameters for each mode.
`OperationDescriptorImpl(java.lang.String[][] resources, java.lang.String[] supportedModes, java.lang.String[] sourceNames, java.lang.Class[][] sourceClasses, java.lang.String[] paramNames, java.lang.Class[][] paramClasses, java.lang.Object[][] paramDefaults, java.lang.Object[][] validParamValues)` Constructor.
`OperationDescriptorImpl(java.lang.String[][] resources, java.lang.String[] supportedModes, java.lang.String[] sourceNames, java.lang.Class[][] sourceClasses, java.lang.String[] paramNames, java.lang.Class[] paramClasses, java.lang.Object[] paramDefaults, java.lang.Object[] validParamValues)` Constructor.

Method Summary
`boolean` `arePropertiesSupported()` Does this descriptor support properties ?
`protected static java.lang.Class` `getDefaultSourceClass(java.lang.String modeName)` Get the default source class for the supported mode.
`java.lang.Class` `getDestClass()` Deprecated. in favor of `getDestClass("rendered")`
`java.lang.Class` `getDestClass(java.lang.String modeName)` Returns a `Class` that describes the type of destination this operation produces for the specified mode.
`java.lang.Object` `getInvalidRegion(java.lang.String modeName, java.awt.image.renderable.ParameterBlock oldParamBlock, java.awt.RenderingHints oldHints, java.awt.image.renderable.ParameterBlock newParamBlock, java.awt.RenderingHints newHints, OperationNode node)` Calculates the region over which two distinct renderings of an operation may be expected to differ.
`java.lang.String` `getName()` Returns the name of this operation; this is the same as the `GlobalName` value in the resources and is visible to all.
`int` `getNumParameters()` Deprecated. in favor of `getParameterListDescriptor(modeName).getNumParameters()` This will for the time being return the above value for modeName = getSupportedModes()[0]
`int` `getNumSources()` Returns the number of sources required by this operation.
`java.lang.Class[]` `getParamClasses()` Deprecated. in favor of `getParameterListDescriptor(modeName).getParamClasses()` This will for the time being return the above value for modeName = getSupportedModes()[0]
`java.lang.Object[]` `getParamDefaults()` Deprecated. in favor of `getParameterListDescriptor(modeName).getParamDefaults()` This will for the time being return the above value for modeName = getSupportedModes()[0]
`java.lang.Object` `getParamDefaultValue(int index)` Deprecated. in favor of `getParameterListDescriptor(modeName).getParamDefaultValue(...)` This will for the time being return the above value for modeName = getSupportedModes()[0]
`ParameterListDescriptor` `getParameterListDescriptor(java.lang.String modeName)` Returns the `ParameterListDescriptor` that describes the associated parameters (NOT sources).

`java.lang.Number`

`getParamMaxValue(int index)`
Deprecated. in favor of `getParameterListDescriptor(modeName).getParamValueRange()` This will for the time being use `getSupportedModes()[0]` for modeName.

If the parameter is not a sub-class of the `Number` class then this method returns null.

Else if the above getParamValueRange() returns a non-null `Range` then it returns the `getMaxValue()` of that `Range`.

Else returns the `MAX_VALUE` of the corresponding `Number` class.

`java.lang.Number`

`getParamMinValue(int index)`
Deprecated. in favor of `getParameterListDescriptor(modeName).getParamValueRange()` This will for the time being use `getSupportedModes()[0]` for modeName.

If the parameter is not a sub-class of the `Number` class then this method returns null.

Else if the above getParamValueRange() returns a non-null `Range` then it returns the `getMinValue()` of that `Range`.

Else for `Float` and `Double` parameters it returns the corresponding `-MAX_VALUE` and `MIN_VALUE` for other `Number` classes.

`java.lang.String[]` `getParamNames()` Deprecated. in favor of `getParameterListDescriptor(modeName).getParamNames()` This will for the time being return the above value for modeName = getSupportedModes()[0]
`PropertyGenerator[]` `getPropertyGenerators()` Deprecated. as of JAI 1.1 in favor of the equivalent method that specifies the mode name.
`PropertyGenerator[]` `getPropertyGenerators(java.lang.String modeName)` Returns an array of `PropertyGenerator`s implementing the property inheritance for this operator that may be used as a basis for the operation's property management.
`java.lang.Class` `getRenderableDestClass()` Deprecated. in favor of `getDestClass("renderable")`
`java.lang.Class[]` `getRenderableSourceClasses()` Deprecated. in favor of `getSourceClasses("renderable")`
`java.util.ResourceBundle` `getResourceBundle(java.util.Locale locale)` Returns the resource data for this operation in a `ResourceBundle`.
`java.lang.String[][]` `getResources(java.util.Locale locale)` Returns the resource data for this operation.
`java.lang.Class[]` `getSourceClasses()` Deprecated. in favor of `getSourceClasses("rendered")`
`java.lang.Class[]` `getSourceClasses(java.lang.String modeName)` Returns an array of `Class`es that describe the types of sources required by this operation for the specified mode.
`java.lang.String[]` `getSourceNames()` Returns an array of `String`s that are the names of the sources of this operation.
`java.lang.String[]` `getSupportedModes()` The registry modes supported by this descriptor.
`boolean` `isImmediate()` Returns `true` if the operation should be computed immediately for all supported modes of this operation during the call to `JAI.create()`; that is, the operation is placed in immediate mode.
`boolean` `isModeSupported(java.lang.String modeName)` Does this descriptor support the specified registry mode ?.
`boolean` `isRenderableSupported()` Deprecated. in favor of `isModeSupported("renderable")`
`boolean` `isRenderedSupported()` Deprecated. in favor of `isModeSupported("rendered")`
`protected static java.lang.Class[][]` `makeDefaultSourceClassList(java.lang.String[] supportedModes, int numSources)` Create a list of per mode source classes for each supported mode which can then be passed on to the constructor.
`boolean` `validateArguments(java.awt.image.renderable.ParameterBlock args, java.lang.StringBuffer msg)` Deprecated. in favor of `validateArguments("rendered", ...)`
`boolean` `validateArguments(java.lang.String modeName, java.awt.image.renderable.ParameterBlock args, java.lang.StringBuffer msg)` Returns `true` if this operation/mode is capable of handling the input source(s) and/or parameter(s) specified in the `ParameterBlock`, or `false` otherwise, in which case an explanatory message may be appended to the `StringBuffer`.
`protected boolean` `validateParameters(java.awt.image.renderable.ParameterBlock args, java.lang.StringBuffer msg)` Deprecated. as of JAI 1.1 in favor of `validateParameters(getSupportedModes()[0], ...)`
`protected boolean` `validateParameters(java.lang.String modeName, java.awt.image.renderable.ParameterBlock args, java.lang.StringBuffer msg)` Returns `true` if this operation is capable of handling the input parameters for the specified mode.
`boolean` `validateRenderableArguments(java.awt.image.renderable.ParameterBlock args, java.lang.StringBuffer msg)` Deprecated. in favor of `validateArguments("renderable", ...)`
`protected boolean` `validateRenderableSources(java.awt.image.renderable.ParameterBlock args, java.lang.StringBuffer msg)` Deprecated. as of JAI 1.1 in favor of `validateSources("renderable", ...)`
`protected boolean` `validateSources(java.awt.image.renderable.ParameterBlock args, java.lang.StringBuffer msg)` Deprecated. as of JAI 1.1 in favor of `validateSources("rendered", ...)`
`protected boolean` `validateSources(java.lang.String modeName, java.awt.image.renderable.ParameterBlock args, java.lang.StringBuffer msg)` Returns `true` if this operation supports the specified mode, and is capable of handling the given input source(s) for the specified mode.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### resources

    protected final java.lang.String[][] resources

  The resource tags and their corresponding data, stored as an two-dimensional `String` array.

### supportedModes

    protected final java.lang.String[] supportedModes

  An array of operation modes supported by this operator. Must be a non-empty subset of "rendered", "renderable", "collection" and "renderableCollection" or other image operator modes to be defined later.

### sourceNames

    protected final java.lang.String[] sourceNames

  An array of `String`s that are the names of the sources of this operation. The names must be listed in the order corresponding to the source `Class`es.

Constructor Detail

### OperationDescriptorImpl

    public OperationDescriptorImpl(java.lang.String[][] resources,
                                   java.lang.String[] supportedModes,
                                   java.lang.String[] sourceNames,
                                   java.lang.Class[][] sourceClasses,
                                   java.lang.String[] paramNames,
                                   java.lang.Class[][] paramClasses,
                                   java.lang.Object[][] paramDefaults,
                                   java.lang.Object[][] validParamValues)

  Constructor. Note that `sourceClasses[m][i]` corresponds to the mode `supportedModes[m]` and the source `sourceNames[i]`. Similarly `paramClasses[m][i]` corresponds to the mode `supportedModes[m]` and the parameter `paramNames[i]`. The same holds true for `paramDefaults` and `validParamValues`
  Parameters:
    `resources` - The resource tags and their corresponding data.
    `supportedModes` - The modes that this operator supports. maybe one or more of "rendered", "renderable", "collection", and "renderableCollection" (or other image operation related modes that maybe defined later). Must support at least one mode.
    `sourceNames` - The source names. It may be `null` if this operation has no sources or if the default source naming convention ("source0", "source1", etc.) is to be used.
    `sourceClasses` - The source types required by this operation for each of the above supported modes. can be null if this operation has no sources. The number of sources for each mode must be the same.
    `paramNames` - The localized parameter names. It may be `null` if this operation has no parameters.
    `paramClasses` - The parameter types required by this operation. for each mode. It may be `null` if this operation has no parameters. The number of parameters for each mode must be the same.
    `paramDefaults` - The parameter default values for each parameter for each mode. It may be `null` if this operation has no parameters, or none of the parameters has a default value for any mode. The parameter defaults for an individual mode may be null, if there are no defaults for that mode.
    `validParamValues` - defines the valid values for each parameter for each mode. this can be `null` if the operation has no parameters. Otherwise each element can be filled in as defined in `ParameterListDescriptorImpl.ParameterListDescriptorImpl( Object, String[], Class[], Object[], Object[])`
  Throws:
    `java.lang.IllegalArgumentException` - if `resources` is `null`.
    `java.lang.IllegalArgumentException` - if supportedModes is `null`
    `java.lang.IllegalArgumentException` - if the number of `sourceClasses` for each mode is not the same or is not equal to the number of sourceNames (if non-null).
    `java.lang.IllegalArgumentException` - if this operation has parameters and `paramClasses` or `paramNames` is `null`.
    `java.lang.IllegalArgumentException` - if `sourceNames` is non-`null` and its length does not equal the number of sources of this operation.
    `java.lang.IllegalArgumentException` - if this operation has parameters and `paramClasses`, `paramNames`, and `paramDefaults` (if all are not `null`) do not all have the same number of elements.
  Since:
    Java Advanced Imaging 1.1

### OperationDescriptorImpl

    public OperationDescriptorImpl(java.lang.String[][] resources,
                                   java.lang.String[] supportedModes,
                                   java.lang.String[] sourceNames,
                                   java.lang.Class[][] sourceClasses,
                                   java.lang.String[] paramNames,
                                   java.lang.Class[] paramClasses,
                                   java.lang.Object[] paramDefaults,
                                   java.lang.Object[] validParamValues)

  Constructor. This assumes that all modes have the same set of parameter classes, defaults and valid values. Note that `sourceClasses[m][i]` corresponds to the mode `supportedModes[m]` and the source `sourceNames[i]`.
  Parameters:
    `resources` - The resource tags and their corresponding data.
    `supportedModes` - The modes that this operator supports. maybe one or more of "rendered", "renderable", "collection", and "renderableCollection". Must support at least one mode.
    `sourceNames` - The source names. It may be `null` if this operation has no sources or if the default source naming convention ("source0", "source1", etc.) is to be used.
    `sourceClasses` - The source types required by this operation for each of the above supported modes. can be null if this operation has no sources. The number of sources for each mode must be the same.
    `paramNames` - The localized parameter names. It may be `null` if this operation has no parameters.
    `paramClasses` - The parameter types required by this operation. It may be `null` if this operation has no parameters.
    `paramDefaults` - The parameter default values for each parameter It may be `null` if this operation has no parameters, or none of the parameters has a default value.
    `validParamValues` - defines the valid values for each parameter for all modes. this can be `null` if the operation has no parameters. Otherwise it can be filled in as defined in `ParameterListDescriptorImpl.ParameterListDescriptorImpl( Object, String[], Class[], Object[], Object[])`
  Throws:
    `java.lang.IllegalArgumentException` - if `resources` is `null`.
    `java.lang.IllegalArgumentException` - if supportedModes is `null`
    `java.lang.IllegalArgumentException` - if the number of `sourceClasses` for each mode is not the same or is not equal to the number of sourceNames (if non-null).
    `java.lang.IllegalArgumentException` - if this operation has parameters and `paramClasses` or `paramNames` is `null`.
    `java.lang.IllegalArgumentException` - if `sourceNames` is non-`null` and its length does not equal the number of sources of this operation.
    `java.lang.IllegalArgumentException` - if this operation has parameters and `paramClasses`, `paramNames`, and `paramDefaults` (if all are not `null`) do not all have the same number of elements.
  Since:
    Java Advanced Imaging 1.1

### OperationDescriptorImpl

    public OperationDescriptorImpl(java.lang.String[][] resources,
                                   java.lang.String[] supportedModes,
                                   int numSources,
                                   java.lang.String[] paramNames,
                                   java.lang.Class[] paramClasses,
                                   java.lang.Object[] paramDefaults,
                                   java.lang.Object[] validParamValues)

  Constructor. This assumes that all modes have the same set of parameter classes, defaults and valid values. The source names are automatically generated using the default source naming convertion ("source0", "source1", etc.). The source class list is automatically generated using `makeDefaultSourceClassList()` from `numSources` and `supportedModes`
  Parameters:
    `resources` - The resource tags and their corresponding data.
    `supportedModes` - The modes that this operator supports. maybe one or more of "rendered", "renderable", "collection", and "renderableCollection". Must support at least one mode.
    `numSources` - The number of sources.
    `paramNames` - The localized parameter names. It may be `null` if this operation has no parameters.
    `paramClasses` - The parameter types required by this operation. It may be `null` if this operation has no parameters.
    `paramDefaults` - The parameter default values for each parameter It may be `null` if this operation has no parameters, or none of the parameters has a default value.
    `validParamValues` - defines the valid values for each parameter for all modes. this can be `null` if the operation has no parameters. Otherwise it can be filled in as defined in `ParameterListDescriptorImpl.ParameterListDescriptorImpl( Object, String[], Class[], Object[], Object[])`
  Throws:
    `java.lang.IllegalArgumentException` - if `resources` is `null`.
    `java.lang.IllegalArgumentException` - if supportedModes is `null`
    `java.lang.IllegalArgumentException` - if this operation has parameters and `paramClasses` or `paramNames` is `null`.
    `java.lang.IllegalArgumentException` - if this operation has parameters and `paramClasses`, `paramNames`, and `paramDefaults` (if all are not `null`) do not all have the same number of elements.
  Since:
    Java Advanced Imaging 1.1

### OperationDescriptorImpl

    public OperationDescriptorImpl(java.lang.String[][] resources,
                                   java.lang.String[] supportedModes,
                                   java.lang.String[] sourceNames,
                                   java.lang.Class[][] sourceClasses,
                                   ParameterListDescriptor[] pld)

  Constructor which accepts a `ParameterListDescriptor` to describe the parameters for each mode. Note that `sourceClasses[m][i]` corresponds to the mode `supportedModes[m]` and the source `sourceNames[i]`.
  Parameters:
    `resources` - The resource tags and their corresponding data.
    `supportedModes` - The modes that this operator supports. maybe one or more of "rendered", "renderable", "collection", and "renderableCollection". Must support at least one mode.
    `sourceNames` - The source names. It may be `null` if this operation has no sources or if the default source naming convention ("source0", "source1", etc.) is to be used.
    `sourceClasses` - The source types required by this operation for each of the above supported modes. can be null if this operation has no sources. The number of sources for each mode must be the same.
    `pld` - the parameter list descriptor for each mode. Can be `null` if there are no parameters.
  Throws:
    `java.lang.IllegalArgumentException` - if `resources` is `null`.
    `java.lang.IllegalArgumentException` - if supportedModes is `null`
    `java.lang.IllegalArgumentException` - if the number of `sourceClasses` for each mode is not the same or is not equal to the number of sourceNames (if non-null).
    `java.lang.IllegalArgumentException` - if `sourceNames` is non-`null` and its length does not equal the number of sources of this operation.
  Since:
    Java Advanced Imaging 1.1

### OperationDescriptorImpl

    public OperationDescriptorImpl(java.lang.String[][] resources,
                                   java.lang.String[] supportedModes,
                                   java.lang.String[] sourceNames,
                                   java.lang.Class[][] sourceClasses,
                                   ParameterListDescriptor pld)

  Constructor. This assumes that all modes use the same `ParameterListDescriptor`. Note that `sourceClasses[m][i]` corresponds to the mode `supportedModes[m]` and the source `sourceNames[i]`.
  Parameters:
    `resources` - The resource tags and their corresponding data.
    `supportedModes` - The modes that this operator supports. maybe one or more of "rendered", "renderable", "collection", and "renderableCollection". Must support at least one mode.
    `sourceNames` - The source names. It may be `null` if this operation has no sources or if the default source naming convention ("source0", "source1", etc.) is to be used.
    `sourceClasses` - The source types required by this operation for each of the above supported modes. can be null if this operation has no sources. The number of sources for each mode must be the same.
    `pld` - the parameter list descriptor for all modes. Can be `null` if there are no parameters.
  Throws:
    `java.lang.IllegalArgumentException` - if `resources` is `null`.
    `java.lang.IllegalArgumentException` - if supportedModes is `null`
    `java.lang.IllegalArgumentException` - if the number of `sourceClasses` for each mode is not the same or is not equal to the number of sourceNames (if non-null).
    `java.lang.IllegalArgumentException` - if `sourceNames` is non-`null` and its length does not equal the number of sources of this operation.
  Since:
    Java Advanced Imaging 1.1

### OperationDescriptorImpl

    public OperationDescriptorImpl(java.lang.String[][] resources,
                                   java.lang.Class[] sourceClasses,
                                   java.lang.Class[] renderableSourceClasses,
                                   java.lang.Class[] paramClasses,
                                   java.lang.String[] paramNames,
                                   java.lang.Object[] paramDefaults)

  Deprecated. as of Java(tm) Advanced Imaging 1.1 in favor of constructors where supported modes are explicitly specified. Uses `isRenderedSupported()` and `isRenderableSupported()` to figure out the supported modes.

  Constructor.
  Parameters:
    `resources` - The resource tags and their corresponding data.
    `sourceClasses` - The source types required by this operation in the rendered mode. It may be `null` if this operation does not support the rendered mode, or if it has no sources.
    `renderableSourceClasses` - The source types required by this operation in the renderable mode. It may be `null` if this operation does not support the renderable mode, or if it has no sources.
    `paramClasses` - The parameter types required by this operation. It may be `null` if this operation has no parameters.
    `paramNames` - The localized parameter names. It may be `null` if this operation has no parameters.
    `paramDefaults` - The parameter default values. It may be `null` if this operation has no parameters, or none of the parameters has a default value.
  Throws:
    `java.lang.IllegalArgumentException` - if `resources` is `null`.
    `java.lang.IllegalArgumentException` - if this operation supports the rendered mode, and it has sources, and `sourceClasses` is `null`.
    `java.lang.IllegalArgumentException` - if this operation supports the renderable mode, and it has sources, and `renderableSourceClasses` is `null`.
    `java.lang.IllegalArgumentException` - if `sourceClasses` and `renderableSourceClasses` (if both are not `null`) do not have the same number of elements.
    `java.lang.IllegalArgumentException` - if this operation has parameters and `paramClasses` or `paramNames` is `null`.
    `java.lang.IllegalArgumentException` - if this operation has parameters and `paramClasses`, `paramNames`, and `paramDefaults` (if all are not `null`) do not all have the same number of elements.
  See Also:
    `OperationDescriptorImpl(String[][], String[], String[], Class [][], String[], Class [], Object[], Object[])`

### OperationDescriptorImpl

    public OperationDescriptorImpl(java.lang.String[][] resources,
                                   int numSources,
                                   java.lang.Class[] paramClasses,
                                   java.lang.String[] paramNames,
                                   java.lang.Object[] paramDefaults)

  Deprecated. as of Java(tm) Advanced Imaging 1.1 in favor of constructors where supported modes are explicitly specified. Uses `isRenderedSupported()` and `isRenderableSupported()` to figure out the supported modes.

  Constructor for operations that support either the rendered or the renderable or both modes. The class type for all the source(s) of the rendered mode (if supported) is set to `java.awt.image.RenderedImage.class`. The class type for all the source(s) of the renderable mode (if supported) is set to `java.awt.image.renderable.RenderableImage`.
  Parameters:
    `resources` - The resource tags and their corresponding data.
    `numSources` - The number of sources required by this operation. It should not be negative. A negative value indicates this operation has no sources.
    `paramClasses` - The parameter types required by this operation. It may be `null` if this operation has no parameters.
    `paramNames` - The localized parameter names. It may be `null` if this operation has no parameters.
    `paramDefaults` - The parameter default values. It may be `null` if this operation has no parameters, or none of the parameters has a default value.
  Throws:
    `java.lang.IllegalArgumentException` - if `resources` is `null`.
    `java.lang.IllegalArgumentException` - if this operation has parameters and `paramClasses` or `paramNames` is `null`.
    `java.lang.IllegalArgumentException` - if this operation has parameters and `paramClasses`, `paramNames`, and `paramDefaults` (if not `null`) do not all have the same number of elements.
  See Also:
    `OperationDescriptorImpl(String[][], String[], int, String[], Class [], Object[], Object[])`

### OperationDescriptorImpl

    public OperationDescriptorImpl(java.lang.String[][] resources,
                                   java.lang.Class[] sourceClasses)

  Deprecated. since JAI 1.1 in favor of constructors where the mode specfic information is explicitly specified.

  Constructor for operations that supports only the rendered mode and requires no parameters.
  Parameters:
    `resources` - The resource tags and their corresponding data.
    `sourceClasses` - The source types required by this operation in the rendered mode. It may be `null` if this operation has no sources.
  Throws:
    `java.lang.IllegalArgumentException` - if `resources` is `null`.
  See Also:
    `OperationDescriptorImpl(String[][], String[], String[], Class [][], String[], Class [], Object[], Object[])`

### OperationDescriptorImpl

    public OperationDescriptorImpl(java.lang.String[][] resources,
                                   java.lang.Class[] sourceClasses,
                                   java.lang.Class[] renderableSourceClasses)

  Deprecated. since JAI 1.1 in favor of constructors where the mode specfic information is explicitly specified.

  Constructor for operations that supports either the rendered or the renderable or both modes and requires no parameters.
  Parameters:
    `resources` - The resource tags and their corresponding data.
    `sourceClasses` - The source types required by this operation in the rendered mode. It may be `null` if this operation does not support the rendered mode, or if it has no sources.
    `renderableSourceClasses` - The source types required by this operation in the renderable mode. It may be `null` if this operation does not support the renderable mode, or if it has no sources.
  Throws:
    `java.lang.IllegalArgumentException` - if `resources` is `null`.
    `java.lang.IllegalArgumentException` - if this operation supports the rendered mode, and it has sources, and `sourceClasses` is `null`.
    `java.lang.IllegalArgumentException` - if this operation supports the renderable mode, and it has sources, and `renderableSourceClasses` is `null`.
    `java.lang.IllegalArgumentException` - if `sourceClasses` and `renderableSourceClasses` (if both are not `null`) do not have the same number of elements.
  See Also:
    `OperationDescriptorImpl(String[][], String[], String[], Class [][], String[], Class [], Object[], Object[])`

### OperationDescriptorImpl

    public OperationDescriptorImpl(java.lang.String[][] resources,
                                   java.lang.Class[] paramClasses,
                                   java.lang.String[] paramNames,
                                   java.lang.Object[] paramDefaults)

  Deprecated. since JAI 1.1 in favor of constructors where the mode specfic information is explicitly specified.

  Constructor for operations that supports either the rendered or the renderable or both modes and requires no sources.
  Throws:
    `java.lang.IllegalArgumentException` - if `resources` is `null`.
    `java.lang.IllegalArgumentException` - if this operation has parameters and `paramClasses` or `paramNames` is `null`.
    `java.lang.IllegalArgumentException` - if this operation has parameters and `paramClasses`, `paramNames`, and `paramDefaults` (if not `null`) do not all have the same number of elements.
  See Also:
    `OperationDescriptorImpl(String[][], String[], int, String[], Class [], Object[], Object[])`

### OperationDescriptorImpl

    public OperationDescriptorImpl(java.lang.String[][] resources,
                                   int numSources)

  Deprecated. since JAI 1.1 in favor of constructors where the mode specfic information is explicitly specified.

  Constructor for operations that support the rendered mode and possibly the renderable mode and require no parameters. The class type for all the source(s) of the rendered mode is set to `java.awt.image.RenderedImage.class`. The class type for all the source(s) of the renderable mode (if supported) is set to `java.awt.image.renderable.RenderableImage`.
  Parameters:
    `resources` - The resource tags and their corresponding data.
    `numSources` - The number of sources required by this operation. It should not be negative. A negative value indicates this operation has no sources.
  Throws:
    `java.lang.IllegalArgumentException` - if `resources` is `null`.
  See Also:
    `OperationDescriptorImpl(String[][], String[], int, String[], Class [], Object[], Object[])`

Method Detail

### getName

    public java.lang.String getName()

  Returns the name of this operation; this is the same as the `GlobalName` value in the resources and is visible to all. This is also descriptor name under which it is registered in the `OperationRegistry`.
  Specified by:
    `getName` in interface `RegistryElementDescriptor`
  Returns:
    A `String` representing the operation's global name.
  Throws:
    `MissingResourceException` - if the `GlobalName` resource value is not supplied in the `resources`.

### getSupportedModes

    public java.lang.String[] getSupportedModes()

  The registry modes supported by this descriptor. Known modes include those returned by `RegistryMode.getModes()`
  Specified by:
    `getSupportedModes` in interface `RegistryElementDescriptor`
  Returns:
    an array of `String`s specifying the supported modes.
  Since:
    Java Advanced Imaging 1.1
  See Also:
    `RegistryMode`, `RegistryElementDescriptor`

### isModeSupported

    public boolean isModeSupported(java.lang.String modeName)

  Does this descriptor support the specified registry mode ?. The `modeName`s are treated in a case-insensitive (but retentive) manner.
  Specified by:
    `isModeSupported` in interface `RegistryElementDescriptor`
  Parameters:
    `modeName` - the registry mode name
  Returns:
    true, if the implementation of this descriptor supports the specified mode. false otherwise.
  Throws:
    `java.lang.IllegalArgumentException` - if `modeName` is null
  Since:
    Java Advanced Imaging 1.1
  See Also:
    `RegistryElementDescriptor`

### arePropertiesSupported

    public boolean arePropertiesSupported()

  Does this descriptor support properties ?
  Specified by:
    `arePropertiesSupported` in interface `RegistryElementDescriptor`
  Returns:
    The default implementation in this class returns `true` so that properties are always supported. Operations that do not wish to support properties must override this implementation.
  Since:
    Java Advanced Imaging 1.1
  See Also:
    `PropertyGenerator`, `RegistryElementDescriptor`

### getPropertyGenerators

    public PropertyGenerator[] getPropertyGenerators(java.lang.String modeName)

  Returns an array of `PropertyGenerator`s implementing the property inheritance for this operator that may be used as a basis for the operation's property management. The default implementation returns `null`, indicating that source properties are simply copied. Subclasses should override this method if they wish to produce inherited properties.

  For the sake of backward compatibilty, if a deprecated constructor was used to create this object, then this method simply calls its deprecated equivalent, `getPropertyGenerators()`, if the modeName is either "rendered" or "renderable".

  Specified by:
    `getPropertyGenerators` in interface `RegistryElementDescriptor`
  Parameters:
    `modeName` - the registry mode name
  Returns:
    An array of `PropertyGenerator`s, or `null` if this operation does not have any of its own `PropertyGenerator`s.
  Throws:
    `java.lang.IllegalArgumentException` - if `modeName` is null
    `UnsupportedOperationException` - if `arePropertiesSupported` returns `false`
  Since:
    Java Advanced Imaging 1.1
  See Also:
    `RegistryElementDescriptor`

### getParameterListDescriptor

    public ParameterListDescriptor getParameterListDescriptor(java.lang.String modeName)

  Returns the `ParameterListDescriptor` that describes the associated parameters (NOT sources). This method returns null if there are no parameters for the specified modeName. If the specified modeName supports parameters but the implementing class does not have parameters, then this method returns a non-null `ParameterListDescriptor` whose `getNumParameters()` returns 0.
  Specified by:
    `getParameterListDescriptor` in interface `RegistryElementDescriptor`
  Parameters:
    `modeName` -
  Throws:
    `java.lang.IllegalArgumentException` - if `modeName` is null
  Since:
    Java Advanced Imaging 1.1
  See Also:
    `RegistryElementDescriptor`

### getResources

    public java.lang.String[][] getResources(java.util.Locale locale)

  Returns the resource data for this operation. It must contain `String` data for the following tags: "GlobalName", "LocalName", "Vendor", "Description", "DocURL", and "Version". Additional resources should be supplied when appropriate.

  The default implementation simply returns a reference to the local "resources" variable, which should be supplied by each subclass by way of the superclass constructor. It also ignores the `Locale` argument, and always returns the `String`s in the default `Locale`.

  Specified by:
    `getResources` in interface `OperationDescriptor`
  Parameters:
    `locale` - The `Locale` in which to localize the resource data.
  Returns:
    A two-dimensional array of `String`s containing the mandatory and optional resource tags and their corresponding resource data. (String[i][0] is the tag for the i-th resource and String[i][1] is the corresponding data)

### getResourceBundle

    public java.util.ResourceBundle getResourceBundle(java.util.Locale locale)

  Returns the resource data for this operation in a `ResourceBundle`. The resource data are taken from the `getResources()` method.

  The default implementation ignores the `Locale` argument, and always returns the resources in the default `Locale`.

  Specified by:
    `getResourceBundle` in interface `OperationDescriptor`
  Parameters:
    `locale` - The `Locale` in which to localize the resource data.
  Returns:
    A `ResourceBundle` containing mandatory and optional resource information.

### getNumSources

    public int getNumSources()

  Returns the number of sources required by this operation. All modes have the same number of sources.
  Specified by:
    `getNumSources` in interface `OperationDescriptor`

### getSourceClasses

    public java.lang.Class[] getSourceClasses(java.lang.String modeName)

  Returns an array of `Class`es that describe the types of sources required by this operation for the specified mode. If this operation has no sources, this method returns `null`.
  Specified by:
    `getSourceClasses` in interface `OperationDescriptor`
  Parameters:
    `modeName` - the operation mode name
  Throws:
    `java.lang.IllegalArgumentException` - if modeName is `null`
  Since:
    Java Advanced Imaging 1.1

### getSourceNames

    public java.lang.String[] getSourceNames()

  Returns an array of `String`s that are the names of the sources of this operation. If this operation has no sources, this method returns `null`. If this operation has sources but their names were not provided at construction time, then the returned names will be of the form "source0", "source1", etc.
  Specified by:
    `getSourceNames` in interface `OperationDescriptor`
  Since:
    Java Advanced Imaging 1.1

### getDestClass

    public java.lang.Class getDestClass(java.lang.String modeName)

  Returns a `Class` that describes the type of destination this operation produces for the specified mode.

  For the sake of backward compatibilty, if a deprecated constructor was used to create this object, then this method simply calls its deprecated equivalent, if the modeName is either "rendered" or "renderable".

  Specified by:
    `getDestClass` in interface `OperationDescriptor`
  Parameters:
    `modeName` - the operation mode name
  Throws:
    `java.lang.IllegalArgumentException` - if modeName is `null`
  Since:
    Java Advanced Imaging 1.1

### validateSources

    protected boolean validateSources(java.lang.String modeName,
                                      java.awt.image.renderable.ParameterBlock args,
                                      java.lang.StringBuffer msg)

  Returns `true` if this operation supports the specified mode, and is capable of handling the given input source(s) for the specified mode. The default implementation ensures that the `ParameterBlock` has at least the required number of sources. It also verifies the class type of the first `getNumSources()` and makes sure that none of them are `null`. Any extra sources in the `ParameterBlock` are ignored. Subclasses should override this implementation if their requirement on the sources are different from the default. This method is used by `validateArguments` to validate the sources.

  For the sake of backward compatibilty, if a deprecated constructor was used to create this object, then this method simply calls its deprecated equivalent, if the `modeName` is either "rendered" or "renderable".

  Parameters:
    `modeName` - the operation mode name
    `args` - a `ParameterBlock` that has the sources
    `msg` - A string that may contain error messages.
  Throws:
    `java.lang.IllegalArgumentException` - if `args` is `null`.
    `java.lang.IllegalArgumentException` - if `msg` is `null` and the validation fails.
  Since:
    Java Advanced Imaging 1.1
  See Also:
    `validateArguments(java.lang.String, java.awt.image.renderable.ParameterBlock, java.lang.StringBuffer)`

### validateParameters

    protected boolean validateParameters(java.lang.String modeName,
                                         java.awt.image.renderable.ParameterBlock args,
                                         java.lang.StringBuffer msg)

  Returns `true` if this operation is capable of handling the input parameters for the specified mode. The default implementation validates the number of parameters, the class type of each parameter, and null parameter. For non-null parameters, it also checks to see if the parameter value is valid. Subclasses should override this implementation if their requirement on the parameter objects are different from the default. This is used by `validateArguments` to validate the parameters.

  JAI allows unspecified tailing parameters if these parameters have default values. This method automatically sets these unspecified parameters to their default values. However, if a parameter, which has a default value, is followed by one or more parameters that have no default values, this parameter must be specified in the `ParameterBlock`; else this method returns `false`.

  This method sets all the undefined parameters in the `ParameterBlock` to their default values, if the default values are specified.

  Note that `DeferredData` parameters will not be recognized as valid unless the parameter is defined to have class `DeferredData.class`.

  For the sake of backward compatibilty, if a deprecated constructor was used to create this object, then this method simply calls its deprecated equivalent, if the `modeName` is either "rendered" or "renderable".

  Throws:
    `java.lang.IllegalArgumentException` - if `args` is `null`.
    `java.lang.IllegalArgumentException` - if `msg` is `null` and the validation fails.
  Since:
    Java Advanced Imaging 1.1
  See Also:
    `validateArguments(java.lang.String, java.awt.image.renderable.ParameterBlock, java.lang.StringBuffer)`, `ParameterListDescriptorImpl.isParameterValueValid(java.lang.String, java.lang.Object)`

### validateArguments

    public boolean validateArguments(java.lang.String modeName,
                                     java.awt.image.renderable.ParameterBlock args,
                                     java.lang.StringBuffer msg)

  Returns `true` if this operation/mode is capable of handling the input source(s) and/or parameter(s) specified in the `ParameterBlock`, or `false` otherwise, in which case an explanatory message may be appended to the `StringBuffer`.

  This method is the standard place where input arguments are validated against this operation's specification for the specified mode. It is called by `JAI.create()` as a part of its validation process. Thus it is strongly recommended that the application programs use the `JAI.create()` methods to instantiate all the rendered operations.

  The default implementation of this method makes sure that this operator supports the specified mode and then calls `validateSources` and `validateParameters`.

  This method sets all the undefined parameters in the `ParameterBlock` to their default values, if the default values are specified.

  Note that `DeferredData` parameters will not be recognized as valid unless the parameter is defined to have class `DeferredData.class`.

  Specified by:
    `validateArguments` in interface `OperationDescriptor`
  Parameters:
    `modeName` - the operation mode name
    `args` - Input arguments, including source(s) and/or parameter(s).
    `msg` - A string that may contain error messages.
  Throws:
    `java.lang.IllegalArgumentException` - if `modeName` is `null`
  Since:
    Java Advanced Imaging 1.1
  See Also:
    `validateSources(java.lang.String, java.awt.image.renderable.ParameterBlock, java.lang.StringBuffer)`, `validateParameters(java.lang.String, java.awt.image.renderable.ParameterBlock, java.lang.StringBuffer)`

### isImmediate

    public boolean isImmediate()

  Returns `true` if the operation should be computed immediately for all supported modes of this operation during the call to `JAI.create()`; that is, the operation is placed in immediate mode. If `true`, and the computation fails, `null` will be returned from `JAI.create()`. If `false`, `JAI.create()` will return an instance of the appropriate destination class that may be asked to compute itself at a later time; this computation may fail at that time.

  Operations that rely on an external resource, such as a source file, or that produce externally-visible side effects, such as writing to an output file, should return `true` from this method. Operations that rely only on their sources and parameters usually wish to return `false` in order to defer rendering as long as possible.

  The default implementation in this class returns `false` so that deferred execution is invoked. Operations that wish to be placed in the immediate mode must override this implementation.

  Specified by:
    `isImmediate` in interface `OperationDescriptor`

### getInvalidRegion

    public java.lang.Object getInvalidRegion(java.lang.String modeName,
                                             java.awt.image.renderable.ParameterBlock oldParamBlock,
                                             java.awt.RenderingHints oldHints,
                                             java.awt.image.renderable.ParameterBlock newParamBlock,
                                             java.awt.RenderingHints newHints,
                                             OperationNode node)

  Calculates the region over which two distinct renderings of an operation may be expected to differ.

  The class of the returned object will vary as a function of the mode of the operation. For rendered and renderable two- dimensional images this will be an instance of a class which implements `java.awt.Shape`.

  Specified by:
    `getInvalidRegion` in interface `OperationDescriptor`
  Parameters:
    `modeName` - The name of the mode.
    `oldParamBlock` - The previous sources and parameters.
    `oldHints` - The previous hints.
    `newParamBlock` - The current sources and parameters.
    `newHints` - The current hints.
    `node` - The affected node in the processing chain.
  Returns:
    `null` to indicate that there is no common region of validity.
  Throws:
    `java.lang.IllegalArgumentException` - if `modeName` is `null` or if the operation requires either sources or parameters and either `oldParamBlock` or `newParamBlock` is `null`.
    `java.lang.IllegalArgumentException` - if `oldParamBlock` or `newParamBlock` do not contain sufficient sources or parameters for the operation in question.
  Since:
    Java Advanced Imaging 1.1

### getDefaultSourceClass

    protected static java.lang.Class getDefaultSourceClass(java.lang.String modeName)

  Get the default source class for the supported mode. "rendered" - java.awt.image.RenderedImage.class "renderable" - java.awt.image.renderable.RenderableImage.class "collection" - java.util.Collection.class "renderableCollection" - java.util.Collection.class

### makeDefaultSourceClassList

    protected static java.lang.Class[][] makeDefaultSourceClassList(java.lang.String[] supportedModes,
                                                                    int numSources)

  Create a list of per mode source classes for each supported mode which can then be passed on to the constructor. Uses `getDefaultSourceClass(modeName)` to construct this list.

### getPropertyGenerators

    public PropertyGenerator[] getPropertyGenerators()

  Deprecated. as of JAI 1.1 in favor of the equivalent method that specifies the mode name.

  Returns an array of `PropertyGenerator`s implementing the property inheritance for this operation. The default implementation returns `null`, indicating that source properties are simply copied. Subclasses should override this method if they wish to produce inherited properties.
  Specified by:
    `getPropertyGenerators` in interface `OperationDescriptor`
  See Also:
    `getPropertyGenerators(java.lang.String)`

### isRenderedSupported

    public boolean isRenderedSupported()

  Deprecated. in favor of `isModeSupported("rendered")`

  Returns `true` if this operation supports the rendered mode. The default implementation in this class returns `true`.
  Specified by:
    `isRenderedSupported` in interface `OperationDescriptor`
  See Also:
    `isModeSupported(java.lang.String)`

### getSourceClasses

    public java.lang.Class[] getSourceClasses()

  Deprecated. in favor of `getSourceClasses("rendered")`

  Returns the source class types of this operation for the rendered mode. If this operation has no sources, or if it does not support the rendered mode, this method returns `null`.
  Specified by:
    `getSourceClasses` in interface `OperationDescriptor`
  See Also:
    `getSourceClasses(java.lang.String)`

### getDestClass

    public java.lang.Class getDestClass()

  Deprecated. in favor of `getDestClass("rendered")`

  Returns the destination class type of this operation for the rendered mode. The default implementation in this class returns `java.awt.image.RenderedImage.class` if this operation supports the rendered mode, or `null` otherwise.
  Specified by:
    `getDestClass` in interface `OperationDescriptor`
  See Also:
    `getDestClass(java.lang.String)`

### validateArguments

    public boolean validateArguments(java.awt.image.renderable.ParameterBlock args,
                                     java.lang.StringBuffer msg)

  Deprecated. in favor of `validateArguments("rendered", ...)`

  Returns `true` if this operation supports the rendered mode, and is capable of handling the input arguments for the rendered mode. The default implementation validates both the source(s) and the parameter(s).

  Note that `DeferredData` parameters will not be recognized as valid unless the parameter is defined to have class `DeferredData.class`.

  Additional validations should be added by each individual operation based on its specification.

  Specified by:
    `validateArguments` in interface `OperationDescriptor`
  Throws:
    `java.lang.IllegalArgumentException` - if `args` is `null`.
    `java.lang.IllegalArgumentException` - if `msg` is `null` and the validation fails.
  See Also:
    `validateArguments(java.lang.String, java.awt.image.renderable.ParameterBlock, java.lang.StringBuffer)`

### isRenderableSupported

    public boolean isRenderableSupported()

  Deprecated. in favor of `isModeSupported("renderable")`

  Returns `true` if this operation supports the renderable mode. The default implementation in this class returns `false`. Operations that support the renderable mode must override this implementation.
  Specified by:
    `isRenderableSupported` in interface `OperationDescriptor`
  See Also:
    `isModeSupported(java.lang.String)`

### getRenderableSourceClasses

    public java.lang.Class[] getRenderableSourceClasses()

  Deprecated. in favor of `getSourceClasses("renderable")`

  Returns the source class types of this operation for the renderable mode. If this operation has no sources, or if it does not support the renderable mode, this method returns `null`.
  Specified by:
    `getRenderableSourceClasses` in interface `OperationDescriptor`
  See Also:
    `getSourceClasses(java.lang.String)`

### getRenderableDestClass

    public java.lang.Class getRenderableDestClass()

  Deprecated. in favor of `getDestClass("renderable")`

  Returns the destination class type of this operation for the renderable mode. The default implementation in this class returns `java.awt.image.renderable.RenderableImage.class` if this operation supports the renderable mode, or `null` otherwise.
  Specified by:
    `getRenderableDestClass` in interface `OperationDescriptor`
  See Also:
    `getDestClass(java.lang.String)`

### validateRenderableArguments

    public boolean validateRenderableArguments(java.awt.image.renderable.ParameterBlock args,
                                               java.lang.StringBuffer msg)

  Deprecated. in favor of `validateArguments("renderable", ...)`

  Returns `true` if this operation supports the renderable mode, and is capable of handling the input arguments for the renderable mode. The default implementation validates both the source(s) and the parameter(s).

  If this operation does not support the renderable mode, this method returns `false` regardless of the input arguments.

  Note that `DeferredData` parameters will not be recognized as valid unless the parameter is defined to have class `DeferredData.class`.

  Additional validations should be added by each individual operation based on its specification.

  Specified by:
    `validateRenderableArguments` in interface `OperationDescriptor`
  Throws:
    `java.lang.IllegalArgumentException` - if `args` is `null`.
    `java.lang.IllegalArgumentException` - if `msg` is `null` and the validation fails.
  See Also:
    `validateArguments(java.lang.String, java.awt.image.renderable.ParameterBlock, java.lang.StringBuffer)`

### getNumParameters

    public int getNumParameters()

  Deprecated. in favor of `getParameterListDescriptor(modeName).getNumParameters()` This will for the time being return the above value for modeName = getSupportedModes()[0]

  Returns the number of parameters (not including sources) required by this operation.
  Specified by:
    `getNumParameters` in interface `OperationDescriptor`
  See Also:
    `ParameterListDescriptor.getNumParameters()`

### getParamClasses

    public java.lang.Class[] getParamClasses()

  Deprecated. in favor of `getParameterListDescriptor(modeName).getParamClasses()` This will for the time being return the above value for modeName = getSupportedModes()[0]

  Returns the parameter class types of this operation. If this operation has no parameters, this method returns `null`.
  Specified by:
    `getParamClasses` in interface `OperationDescriptor`
  See Also:
    `ParameterListDescriptor.getParamClasses()`

### getParamNames

    public java.lang.String[] getParamNames()

  Deprecated. in favor of `getParameterListDescriptor(modeName).getParamNames()` This will for the time being return the above value for modeName = getSupportedModes()[0]

  Returns the localized parameter names of this operation. If this operation has no parameters, this method returns `null`.
  Specified by:
    `getParamNames` in interface `OperationDescriptor`
  See Also:
    `ParameterListDescriptor.getParamNames()`

### getParamDefaults

    public java.lang.Object[] getParamDefaults()

  Deprecated. in favor of `getParameterListDescriptor(modeName).getParamDefaults()` This will for the time being return the above value for modeName = getSupportedModes()[0]

  Returns the default values of the parameters for this operation. If this operation has no parameters, this method returns `null`. If a parameter does not have a default value, the constant `OperationDescriptor.NO_PARAMETER_DEFAULT` will be returned. The `validateArguments()` and `validateRenderableArguments` method will return `false` if an input parameter without a default value is supplied as `null`, or if an unspecified tailing parameter does not have a default value.
  Specified by:
    `getParamDefaults` in interface `OperationDescriptor`
  See Also:
    `ParameterListDescriptor.getParamDefaults()`

### getParamDefaultValue

    public java.lang.Object getParamDefaultValue(int index)

  Deprecated. in favor of `getParameterListDescriptor(modeName).getParamDefaultValue(...)` This will for the time being return the above value for modeName = getSupportedModes()[0]

  Returns the default value of specified parameter. The default value may be `null`. If a parameter has no default value, this method returns `OperationDescriptor.NO_PARAMETER_DEFAULT`.
  Specified by:
    `getParamDefaultValue` in interface `OperationDescriptor`
  Parameters:
    `index` - The index of the parameter whose default value is queried.
  Throws:
    `java.lang.IllegalArgumentException` - if this operation has no parameters.
    `ArrayIndexOutOfBoundsException` - if there is no parameter corresponding to the specified `index`.
  See Also:
    `ParameterListDescriptor.getParamDefaultValue(java.lang.String)`

### getParamMinValue

    public java.lang.Number getParamMinValue(int index)

  Deprecated. in favor of `getParameterListDescriptor(modeName).getParamValueRange()` This will for the time being use `getSupportedModes()[0]` for modeName.

  If the parameter is not a sub-class of the `Number` class then this method returns null.

  Else if the above getParamValueRange() returns a non-null `Range` then it returns the `getMinValue()` of that `Range`.

  Else for `Float` and `Double` parameters it returns the corresponding `-MAX_VALUE` and `MIN_VALUE` for other `Number` classes.

  Returns the minimum legal value of a specified numeric parameter for this operation. If the specified parameter is non-numeric, this method returns `null`.

  The return value should be of the class types corresponding to the parameter's primitive type, that is, `Byte` for a `byte` parameter, `Integer` for an `int` parameter, and so forth.

  The default implementation returns the minimum value in the parameter data type's full range.

  Specified by:
    `getParamMinValue` in interface `OperationDescriptor`
  Parameters:
    `index` - The index of the parameter to be queried.
  Returns:
    A `Number` representing the minimum legal value, or `null` if the specified parameter is not numeric.
  Throws:
    `java.lang.IllegalArgumentException` - if this operation has no parameters.
    `ArrayIndexOutOfBoundsException` - if there is no parameter corresponding to the specified `index`.
  See Also:
    `ParameterListDescriptor.getParamValueRange(java.lang.String)`, `ParameterListDescriptor.getEnumeratedParameterValues(java.lang.String)`, `ParameterListDescriptor.isParameterValueValid(java.lang.String, java.lang.Object)`

### getParamMaxValue

    public java.lang.Number getParamMaxValue(int index)

  Deprecated. in favor of `getParameterListDescriptor(modeName).getParamValueRange()` This will for the time being use `getSupportedModes()[0]` for modeName.

  If the parameter is not a sub-class of the `Number` class then this method returns null.

  Else if the above getParamValueRange() returns a non-null `Range` then it returns the `getMaxValue()` of that `Range`.

  Else returns the `MAX_VALUE` of the corresponding `Number` class.

  Returns the maximum legal value of a specified numeric parameter for this operation. If the specified parameter is non-numeric, this method returns `null`.

  The return value should be of the class type corresponding to the parameter's primitive type, that is, `Byte` for a `byte` parameter, `Integer` for an `int` parameter, and so forth.

  The default implementation returns the maximum value in the parameter data type's full range.

  Specified by:
    `getParamMaxValue` in interface `OperationDescriptor`
  Parameters:
    `index` - The index of the parameter to be queried.
  Returns:
    A `Number` representing the maximum legal value, or `null` if the specified parameter is not numeric.
  Throws:
    `java.lang.IllegalArgumentException` - if this operation has no parameters.
    `ArrayIndexOutOfBoundsException` - if there is no parameter corresponding to the specified `index`.
  See Also:
    `ParameterListDescriptor.getParamValueRange(java.lang.String)`, `ParameterListDescriptor.getEnumeratedParameterValues(java.lang.String)`, `ParameterListDescriptor.isParameterValueValid(java.lang.String, java.lang.Object)`

### validateSources

    protected boolean validateSources(java.awt.image.renderable.ParameterBlock args,
                                      java.lang.StringBuffer msg)

  Deprecated. as of JAI 1.1 in favor of `validateSources("rendered", ...)`

  Returns `true` if this operation supports the rendered mode, and is capable of handling the given input source(s) for the rendered mode. The default implementation validates the number of sources, the class type of each source, and null sources. Subclasses should override this implementation if their requirement on the sources are different from the default.
  Throws:
    `java.lang.IllegalArgumentException` - if `args` is `null`.
    `java.lang.IllegalArgumentException` - if `msg` is `null` and the validation fails.
  See Also:
    `validateSources(java.lang.String, java.awt.image.renderable.ParameterBlock, java.lang.StringBuffer)`

### validateRenderableSources

    protected boolean validateRenderableSources(java.awt.image.renderable.ParameterBlock args,
                                                java.lang.StringBuffer msg)

  Deprecated. as of JAI 1.1 in favor of `validateSources("renderable", ...)`

  Returns `true` if this operation supports the renderable mode, and is capable of handling the given input source(s) for the renderable mode. The default implementation validates the number of sources, the class type of each source, and null sources. Subclasses should override this implementation if their requirement on the sources are different from the default.
  Throws:
    `java.lang.IllegalArgumentException` - if `args` is `null`.
    `java.lang.IllegalArgumentException` - if `msg` is `null` and the validation fails.
  See Also:
    `validateSources(java.lang.String, java.awt.image.renderable.ParameterBlock, java.lang.StringBuffer)`

### validateParameters

    protected boolean validateParameters(java.awt.image.renderable.ParameterBlock args,
                                         java.lang.StringBuffer msg)

  Deprecated. as of JAI 1.1 in favor of `validateParameters(getSupportedModes()[0], ...)`

  Returns `true` if this operation is capable of handling the given input parameters. The default implementation validates the number of parameters, the class type of each parameter, and null parameters. For those non-null numeric parameters, it also checks to see if the parameter value is within the minimum and maximum range. Subclasses should override this implementation if their requirements for the parameter objects are different from the default.

  JAI allows unspecified tailing parameters if these parameters have default values. This method automatically sets these unspecified parameters to their default values. However, if a parameter, which has a default value, is followed by one or more parameters that have no default values, this parameter must be specified in the `ParameterBlock`; else this method returns `false`.

  Note that `DeferredData` parameters will not be recognized as valid unless the parameter is defined to have class `DeferredData.class`.

  Throws:
    `java.lang.IllegalArgumentException` - if `args` is `null`.
    `java.lang.IllegalArgumentException` - if `msg` is `null` and the validation fails.
  See Also:
    `validateParameters(java.lang.String, java.awt.image.renderable.ParameterBlock, java.lang.StringBuffer)`