Public

getNumParameters

getParamNames

getParamClasses

getParamDefaults

getParamValueRange

getEnumeratedParameterNames

getEnumeratedParameterValues

getParamDefaultValue

LocalDateTime

Creating JSON documents from java classes using gson

This class represents proxy server settings. A created instance of Proxy stores
a type and an addres

java.net.Proxy

Doubly-linked list implementation of the List and Dequeinterfaces. Implements
all optional list oper

java.util.LinkedList

A collection designed for holding elements prior to processing. Besides basic
java.util.Collection o

java.util.Queue

TimeZone represents a time zone offset, and also figures out daylight savings. 
Typically, you get a

java.util.TimeZone

A plug-in replacement for JDK1.5 java.util.concurrent.ConcurrentHashMap. This
version is based on or

java.util.concurrent.ConcurrentHashMap

javax.swing.JFrame

onCreateOptionsMenu

setScale

setContentView

/**
     * Returns the JAI's parameters as {@link ParameterDescriptor} objects. This method is a work
     * around for RFE #4093999 in Sun's bug database ("Relax constraint on placement of
     * this()/super() call in constructors").
     */

/*
         * Creates the list of JAI descriptor to be replaced by user-supplied parameters.
         * Note that this map will be modified again in the remaining of this method.
         */

/*
         * JAI considers sources as a special kind of parameters, while GridCoverageProcessor makes
         * no distinction. If the registry element "operation" is really a JAI's OperationDescriptor
         * (which should occurs most of the time), prepend the JAI's sources before all ordinary
         * parameters. In addition, transforms the source type if needed.
         */

/*
                     * If there is only one source argument, rename for example "Source0"
                     * as "Source" for better compliance with OpenGIS usage. However, we
                     * will keep the original name as an alias.
                     */

/*
         * Source parameters completed. Now get the ordinary parameters. We check for
         * replacement of JAI parameters by user-supplied parameters in this process.
         */

/*
         * Appends the remaining extra descriptors. Note that some descriptor may
         * have been removed from the 'replacements' map before we reach this point.
         */

/**
     * Creates and fills the {@link #values} list. Note: this method must creates elements
     * inconditionnally and most not requires synchronization for proper working of the {@link
     * #clone} method.
     *
     * @return The array which is backing {@link #values}. This array is returned only in order to
     *     allow {@link #clone} to modify the values right after the clone. In other cases, this
     *     array should be discarted.
     */

/*
                 * Found a parameter which is a member of the JAI ParameterList, and the
                 * type matches the expected one. Uses 'parameters' as the backing store.
                 */

/*
                 * In theory, we should use ParameterBlock sources. However, we can't because
                 * the type is not the same: JAI operations typically expect a RenderedImage
                 * source, while coverage operations typically expect a GridCoverage source.
                 * The value will be stored separatly, and the coverage framework will need
                 * to handle it itself.
                 */

/*
         * Checks for name clashes.
         */

// can happen if the op has trouble setting up its rendering

//            if (logger.isTraceEnabled())

//                Log4jUtil.trace(logger, ignored.getMessage(), ignored);

/**
     * Returns a tree view of all operations registered in the given registry.
     *
     * @param  registry The registry (e.g. {@link JAI#getOperationRegistry()}).
     * @param  locale The locale (e.g. {@link Locale#getDefault()}).
     * @return All JAI operations as a tree.
     *
     * @see #getTree()
     * @see JAI#getDefaultInstance()
     * @see JAI#getOperationRegistry()
     * @see Locale#getDefault()
     */

/*
         * Add registry modes ("rendered", "renderable", etc.),
         * and gets the operation descriptors for each mode.
         */

/*
             * Add the operations ("add", "convolve", etc.) and their parameters.
             */

// Should not be NamedTreeNode, because the later is used for

// differentiating parameters and implementations (see below).

/*
                 * Add the implementing products and the factories, if any.
                 */

// The node class (NamedTreeNode) should be different from the

// node for parameters (see above), in order to differentiate

//                Logger logger = Logger.getLogger(RenderedImageBrowser.class);

//                if (logger.isTraceEnabled())

//                    Log4jUtil.trace(logger, ignored.getMessage(), ignored);

// dump the rendered op params if we have some

/**
     * Convenience method for setting the parameter description from a JAI operation node.
     *
     * @param operation The operation node for the current parameter.
     * @param index     The parameter index, or {@code -1} if unknow.
     *
     * @since 2.3
     */

/*
             * If a parameter is specified, gets the parameter type and its range of valid
             * values.
             */

/*
             * If the descriptor is an operation, gets the localized operation
             * description or the parameter description.
             */

// No description for this parameter. Try a global description.

/*
                         * No description at all for this operation. Not a big deal;
                         * just left the description empty. Log the exception with a
                         * low level, since this warning is not really important. The
                         * level is slightly higher than in 'RegisteredOperationBrowser'
                         * since we have tried the global operation description as well.
                         */

/**
     * Add the parameters from the specified operation to the specified tree node.
     *
     * @param root The tree node to add parameters to.
     * @param operation The operation for which to fetch parameters.
     * @param  locale The locale for tree node names.
     */

/**
     * Not actually a unit-test, its just a code snippet allowing
     * to explore API specification and object state of a JAI RenderedOp.
     */

How to use getParamNamesmethodin javax.media.jai.ParameterListDescriptor

Best Java code snippets using javax.media.jai.ParameterListDescriptor.getParamNames (Showing top 10 results out of 315)

How to use
getParamNames
method
in
javax.media.jai.ParameterListDescriptor