Public

getNumParameters

getParamNames

getParamClasses

getParamDefaults

getParamValueRange

getEnumeratedParameterNames

getEnumeratedParameterValues

getParamDefaultValue

Running tasks concurrently on multiple threads

A flow layout arranges components in a left-to-right flow, much like lines of
text in a paragraph. F

java.awt.FlowLayout

Wraps an existing Writer and buffers the output. Expensive interaction with the
underlying reader is

java.io.BufferedWriter

A linear collection that supports element insertion and removal at both ends.
The name deque is shor

java.util.Deque

The exception that is thrown when a handshake could not be completed
successfully.

javax.net.ssl.SSLHandshakeException

javax.swing.JButton

Central representation of an Ant project. This class defines an Ant project with
all of its targets,

org.apache.tools.ant.Project

getSupportFragmentManager

startActivity

setRequestProperty

/**
     * 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