All Classes and Interfaces
Class
Description
Base class for node data service client implementations, such as
JsonRpcClient.Base class for node data service client implementations that support only one service interface, such as
JsonRpcSingleClient.Abstract implementation of the
Wrapper interface that keeps the wrapped object as local member.An annotation for a layout part to ensure that the annotated element appears after the referenced layout part.
An interface use to make repeatable
A logical AND
Operator that combines multiple child Expressions.Represents a (workflow) annotation id as used by gateway entities and services.
A data service that applies the data to the underlying model (usually the
NodeModel).The builder.
Apply this condition in a signal at an array layout field (NOT to a field in the Element POJO).
A utility class for working with array layouts.
An annotation to set the button text and element title of array or collection settings.
This class is used to trigger computations of the choices of a
ChoicesWidget when computing the initial data
for receiving the result (as a Future in the data service) to enable asynchronous fetching of the choices
while still starting the computation as early as possible.Marker interface to be implemented by to be implemented by a
ChoicesProvider.UI-interface that provides asynchronous versions of some methods of
NodeContainerUI - see AsyncUI.UI-interface that provides asynchronous versions of some methods of
NodeOutPortUI - see also AsyncUI.Marker-interface for all *asynchronous* eclipse-UI related components.
UI-interface that provides asynchronous versions of some methods of
WorkflowAnnotation - see also
AsyncUI.UI-interface that provides asynchronous versions of some methods of
WorkflowManagerUI - see AsyncUI.An annotation for a layout part to ensure that the annotated element appears before the referenced layout
part.
An interface use to make repeatable
The interface defining that a
ButtonWidget.actionHandler() has to extend.This class exists in order to communicate what changes should be made to a button component after a call to a
ButtonActionHandler or a ButtonUpdateHandler.An interface used to defining the underlying state machine of the action handler within a
ButtonWidget.A handler for updating the button state when another setting changes its value.
This annotation can be applied to a field of any serializable type, in order to display a button widget which, on
click, invokes an action specified by the given actionHandler.
An
ButtonActionHandler with an asynchronous invocation whose result can be retrieved and canceled.A simple update handler which will reset the current state of the button to the ready state when a triggering
setting changes.
A simple functional interface for unifying the transformation of
DataCells to serializable objects.Helper to identify components that needs an update.
This generator can be used to get the representation of the choices in a
ChoicesWidget which we send via the
uischema to the front-end.A class that provides an array of possible values based on the current
DefaultNodeSettings.DefaultNodeSettingsContext.A handler for updating the possible values of a
ChoicesWidgetA widget supplied with an array of possible values, which are the choices for a selection.
A representation of a
ColorModel which is used by the frontend to handle colors.A class that provides an array of possible column choices based on the current
DefaultNodeSettings.DefaultNodeSettingsContext.A class used to store several representation of column choices.
This enum lists the possibilities of how to choose from a set of table columns
A interface to communicate the columnName representing a setting to a dependent setting with an update handler.
A class used to store a selected column together with additional information (e.g.
Annotate a String[] field which is a
ChoicesWidget in order to display a combo box component.Wrapper for
CompletableFutures that additionally re-throws a predefined exception on calling
CompletableFutureEx.getOrThrow().A condition which can be invoked on a setting using the
Signal annotation.A visitor visiting all permitted implementations of
Condition which is used to translate the condition to a
implementation dependent format.UI-interface that mirrors the
ConnectionContainer.UI-interface implementation that wraps a
ConnectionContainer.Represents a connection id as used by gateway entities and services.
Context object supplier that either takes a
NodeContainer or a NodeContainerUI and converts it into
NodeContainer, NodeContainerUI, WorkflowManager, or WorkflowManagerUI.A
NodeSettingsPersistor for Credentials objects.The widget annotation to customize the labels of a
Credentials setting.Describes how
DataCell are supposed to be rendered in the table on the frontend side.Common interface for all data service types.
Common interface for all data service builder types.
A
DataServiceContext allows to report warning messages during a data service invocation or assembly of
initial data.This exception can be thrown during a data service invocation or assembly of initial data.
Manages data service instances created by
DataServiceProvider-implementations.Provides different types of data services.
Holds information related to a
DataType.An image-based renderer as required by the
TableViewDataService.Allows one to (short-term) register
DataValueImageRenderers together with their
respective DataValues to render.Common interface for renderers as required by the
TableViewDataService.Factory for
DataValueRenderers as required by the TableViewDataService.A text renderer.
A widget annotation to display a date string as a date picker with several formatting options.
An annotation to specify which setting exactly a setting with an attached
DependencyHandler is dependent of
in case the path of the field exists in more than one of the supplied DefaultNodeSettingsA settings converter as used by the
FlowVariableDataServiceImplThe converter used in the
FlowVariableDataServiceImpl of the DefaultNodeDialog.The atomic expression that is used for json forms implementation
Default node dialog implementation where all the dialog widgets are defined through a
DefaultNodeSettings-implementation.Implementation of the
DefaultNodeDialogDataService.Marker interface for implementations that define a
DefaultNodeDialog.A context that holds any available information that might be relevant for creating a new instance of
DefaultNodeSettings.This class is used to construct new
NodeSettings to initialize them.This class is used to traverse the settings within
DefaultNodeSettings.Serializes POJOs into strings using the same object mapper as is used for
DefaultNodeSettings-implementations.A
NodeSettingsService decorator that can be used to enable saving and loading flow variables of
NodeDialog using the DefaultNodeDialog.getPage() page.Provides the default for a field.
A utility class for validating view
DefaultNodeSettings instances overwritten by flow variables.The fields specified in this class have to reference other settings of the current node settings.
With this annotation a field, all fields in a class, or a whole layout part (i.e.
This enum represents the effect that a rule has on a setting.
This field persistor transforms
String node settings to enum values and vice versa by matching the enum
constant.Interface for an event consumer that accepts event usually emitted by an
EventSource.An event source produces events that are forwarded to an event consumer.
An expression in terms of propositional logic.
ExpressionVisitor<T,E extends org.knime.core.webui.node.dialog.defaultdialog.rule.AtomicExpression<E>>
A visitor visiting all permitted implementations of
Expression which is used to translate the expression to a
implementation dependent format.Triggers when a boolean is false.
A holder for annotations of a field during the traversal of nested settings of DefaultNodeSettings.
This exception is thrown when for a nested field both the enclosing field and the enclosing class have the same
kind of annotation which is one of the tracked ones.
Performs persistence of DefaultNodeSettings on a per-field basis.
A
NodeSettingsPersistor that persists a single field of a settings object.This settings class can be used to display a dropdown from which several file system categories can be selected
(currently only local and custom/KNIME URLs).
A data service used in the
DefaultNodeDialog or any other NodeDialog using the same page and having
flow variables.Adds additional methods to the
PageBuilder which allows one to define the page content and associated
resources by referencing files.This is the default persistor used for the path field of the
FSLocation.A utility class to calculate the tanimoto bi-gram similarity, originally copied from the Tanimoto BiGram distance
from the distmatrix package.
Triggers if the respective field has at least 2 elements.
Annotate a setting with this to hide it from the dialog.
Annotation to mark a class as a horizontal layout.
This represents one of the possible values within a
ChoicesWidget.IdentityOperation<E extends org.knime.core.webui.node.dialog.defaultdialog.rule.AtomicExpression<E>>
Service to provide the data required to initialize an UI extension.
The builder.
Utilities around a nodes input
PortObjectSpecs.An annotation for a layout part to ensure that the annotated element appears nested inside the referenced
layout part.
InteractiveWebViewsResultUI<T extends org.knime.core.node.AbstractNodeView.ViewableModel & org.knime.core.node.wizard.WizardNode<REP,VAL>,REP extends org.knime.core.node.web.WebViewContent,VAL extends org.knime.core.node.web.WebViewContent>
Return value of
NodeContainerUI.getInteractiveWebViews().InteractiveWebViewsResultUI.SingleInteractiveWebViewResultUI<T extends org.knime.core.node.AbstractNodeView.ViewableModel & org.knime.core.node.wizard.WizardNode<REP,VAL>,REP extends org.knime.core.node.web.WebViewContent,VAL extends org.knime.core.node.web.WebViewContent>
Represents a single web view, currently a model and a name.
InteractiveWebViewsResultWrapper<T extends org.knime.core.node.AbstractNodeView.ViewableModel & org.knime.core.node.wizard.WizardNode<REP,VAL>,REP extends org.knime.core.node.web.WebViewContent,VAL extends org.knime.core.node.web.WebViewContent>
UI-interface implementation that wraps a
InteractiveWebViewsResult.Condition that triggers when "None" column is selected.
Condition that triggers when "None" column is selected.
Condition to be used for
ColumnSelection fields.Condition to be used when an field serialized to a string should trigger a
Signal when it matches a specific
string.Used to de-serialize JSON data to
DefaultNodeSettings to be further transformed to NodeSettings.The tags, types and formats used in a jsonforms schema
The tags, options and types used in the construction of a jsonforms ui-schema
Several formats which are written to the options of the ui-schema of an ui element
Utility class mainly for creating json-forms data content from a
DefaultNodeSettings POJO and vice-versa.Utility class for creating schema content from a settings POJO class.
Data service that provides all data that is necessary to generate a JSON Forms
dialog, i.e., a schema, data, and a UI schema.
Abstract implementation of JsonFormsSettings, where
the schema content is created from the types, names, and annotations of the fields in model and view
settings (see JsonFormsSchemaUtil)
the data content is created from the values in these fields (see JsonFormsDataUtil)
the UI schema content is created either from a uischema.json file that resides in the same folder as the model
and view settings classes or, if no such file exists, it is generated from settings annotations (see
JsonFormsUiSchemaUtil)
Class for creating ui schema content from a settings POJO class.
Helper to translate json-objects (
ObjectNode) into NodeSettings and vice-versa.A JSON-RPC based implementation of a node data service client.
A wrapper for the
JsonRpcMultiServer; a simple delegate in case we want to exchange the JSON-RPC
implementation.A JSON-RPC based implementation of a node data service client.
A convenience specialization of
JsonRpcServer that supports only one service interface and thus spares the
user from specifying the service interface name every time.Utility methods for de-/serialization testing of data service calls and their results for json-rpc server and client
implementations.
This annotation can be used to label the values of an enum as they should appear in the desired widget (value
switch, radio buttons, ...)
An annotation for controlling which part of a layout a given field should be.
If a (possibly nested) field within a
DefaultNodeSettings class is an instance of a class extending this
interface, it will not be treated as a setting during the creation of the user interface and instead its nested
fields are respected.A representation of a layout part class which is used in
LayoutTree to determine the structure between all
layout parts.A workflow manager that isn't complete on instantiation and requires to (down-)load data (only once) before all
methods can be used.
NodeSettingsPersistor for ColumnFilter that persists it in a way compatible to
DataColumnSpecFilterConfiguration.Put this annotation on a String setting in order to enable a file chooser next to the string input field.
A utility class existing because it is tedious in java to perform even simple operations on the values of maps.
UI-interface that mirrors the
NativeNodeContainer.UI-interface implementation that wraps a
NativeNodeContainer.Represents
NodeSettingsRO and VariableSettingsRO.Represents
NodeSettingsWO and VariableSettingsWO.Helper to clean-up after a node removal, workflow disposal or (optionally) node state change.
A mechanism to expose the
NodeContainerUI.doRpc(String) to org.knime.core without adding a dependency
from org.knime.core to org.knime.core.ui.UI-interface that mirrors the
NodeContainer.NodeContainerWrapper<W extends org.knime.core.node.workflow.NodeContainer>
UI-interface implementation that wraps a
NodeContainer.Represents a dialog of a node.
Can be implemented and provided to the NodeDialog upon creation.
Node dialog entity containing the info required by the UI (i.e.
Implemented by
NodeFactorys to register a node dialog.Manages (web-ui) node dialog instances and provides associated functionality.
Represents a node id as used by gateway entities and services (and the UI in general).
Represents some basic information on a node required to display node views in the UI (e.g.
Represents a node in-port of a
NodeContainerUI.UI-interface implementation that wraps a
NodeInPort.Interface for a node's output port (mainly for the
NodeContainerUI).UI-interface implementation that wraps a
NodeOutPort.Node port interface which keeps an index and a port name.
A
NodeWrapper that identifies an output port on an instantiated node.Class that manages the node recommendations.
Interface for a listener that gets notified when the recommendations are updated (via
NodeRecommendationManager.loadRecommendations().Object representing one node recommendation, including the node template itself and a frequency as a measure of a
certainty for the given recommendation.
NodeRpcServerFactory<M extends org.knime.core.node.NodeModel>
Deprecated, for removal: This API element is subject to removal in a future version.
rpc services are directly provided by a node's view, dialog or port.
Implementing classes save objects to and load objects from NodeSettings.
Custom implementations must be immutable and provide either an empty or a constructor that accepts the
Class
of the persisted object as input.Creates and caches NodeSettingsPersistors for DefaultNodeSettings.
Extend this persistor in order to write custom persistors which need to access the configKey of a field during save
or load.
Functionality around
NodeSettings as required by the NodeDialog.This class can be used to transform
NodeSettings first to DefaultNodeSettings and then further to
JsonFormsSettings.Represents a view of a node which views a single table given in one of the input ports.
Class that provides triples of nodes and their count.
Interface for a factory that creates
NodeTripleProviders.Super classes for node-ui-extension entities, e.g., node view and node dialog.
Represents a view of a node.
Node view entity containing the info required by the UI (i.e.
NodeViewFactory<T extends org.knime.core.node.NodeModel>
Implemented by
NodeFactorys to register a node view.Manages (web-ui) node view instances and provides associated functionality.
An event that signals a node view to update itself.
Emits
NodeViewStateEvents which signal a node view to update itself (depending on the
underlying node state).Wrapper for a node (
NodeContainer).Implemented by
NodeFactories in order to provide a custom node-wrapper-type-id as returned by
NodeWrapper.getNodeWrapperTypeId().Marker class that is only meant to serve as a default in
ButtonWidget.updateHandler().Marker class that is only meant to serve as a default in
ChoicesWidget.choicesUpdateHandler().Exception thrown when a
LazyWorkflowManagerUI hasn't been loaded, yet.Annotate a number setting with this in order to provide validation instructions.
Provides a double value given the context of the node.
A POJO representation of a
ColorModelRange which is serialized and provided to the frontend in order to
access colors by numeric values using an interpolation in the frontend which mimics the interpolation process given
in ColorModelRange.Utility class around Jackson's
ObjectMapper.Triggers if an enum has one of a specified subset of values.
Indicates that an operation is not allowed.
An expression defining how to logically combine other expressions.
A (html) page of an ui-extension, e.g.
Supplier of a InputStream.Builds a
Page.Helps to determined the size of a page if it's composed with other pages (e.g.
The path segments that contribute to a page path as it's returned by
PageResourceManager.getPagePath(NodeWrapper).Gives access to the pages and page resources for nodes (i.e.
The page kinds, i.e.
Since we do not want to send passwords to the frontend when serializing
Credentials, we need to store them
temporarily in order to receive passwords again when deserializing.Add this annotation to a
Credentials setting in order to display a single password input field.Use this annotation for text inputs in order to trigger an effect when the supplied pattern is met.
Allows to define the persistence of individual fields to NodeSettings if field based persistence is used.
The implementations must follow the following conventions:
It must provide an empty constructor.
This is a decorator for the
AsyncChoicesAdder which is used in cases where an added choice needs to be kept
indefinitely regardless of the number of times it was already retrieved (e.g.Annotates a class with a persistor that is used to save and load objects of the class to and from NodeSettings.
Similar to the
NodeContext, but holds contextual information about a NodePort for operations carried
out for a port (e.g.Describes an input or output port of a node.
PortSpecViewFactory<S extends org.knime.core.node.port.PortObjectSpec>
Factory for views of
PortObjectSpecs.Represents a view of a port.
Port view entity containing the info required by the UI (i.e.
PortViewFactory<T extends org.knime.core.node.port.PortObject>
Pending API - needs to be integrated with
PortObject/PortType.Manages (web-ui) port view instances and provides associated functionality.
Describes the views associated with some
PortType.This represents one of the possible values within a
ChoicesWidget with a ColumnChoicesProvider.Annotate an
Enum setting with this in order to display them as radio buttons instead of the default (dropdown
list).Contains utility functions for dealing with reflection.
This class holds information about the context in which a remote workflow (e.g.
Represents a render that turns data values into something visual in a table cell.
Represents a web resource used in ui-extensions (such as node view, port view and node dialog).
The resource content type.
Information around the web resource (e.g.
Annotate a
String setting with this widget to edit its content with a rich text editor.An interface used in
TableSectionRenderer to render the rows to lists.This decorator adds the row Index of the currently rendered table at first position.
Decorator row renderer which renders the index of the row as a first element.
Decorator row renderer which renders the rowKey of the row as a first element.
Deprecated, for removal: This API element is subject to removal in a future version.
can be removed since we don't need a java-based RpcClient anymore once the Remote Workflow Editor becomes
obsolete
A
RpcDataService where the requests result in actual method-calls of registered handler(s) (aka remote
procedure calls).The builder.
An
RpcServer implementation is used to serve remote requests to one or more node data services.To be implemented by a node model's factory if the node model provides a node data service.
Deprecated, for removal: This API element is subject to removal in a future version.
rpc services are directly provided by a node view, dialog or port.
Deprecated, for removal: This API element is subject to removal in a future version.
can be removed since we don't need a java-based RpcClient anymore once the Remote Workflow Editor becomes
obsolete
Convenience specialization of
RpcServer for the case where there is only node data service interface, which
the user then doesn't have to specify on every call.To deliver remote procedure calls to a remote (different machine and/or language) rpc server provided by a node
factory, different mechanisms can be used.
Used in defining the RpcTransportFactory extension point (which exposes the NodeContainerUI class from
org.knime.core.ui to org.knime.core) in order to send remote procedure calls.
Annotation to mark a class as a section which can contain several settings and other layout parts.
A selection event.
An event source that emits selection events (i.e.
The mode of selection event.
Translates between lists of row keys (representing a selection on the backend-side) and a list of strings
(representing the selection on the frontend-side).
A settings type (usually associated with
NodeSettings instances) denotes whether certain settings are going
to be loaded into a NodeModel or a NodeView.This annotation is necessary to set up the conditions of a rule with a target specified by the
Effect.This interface is used as a container for fields with repeated
Signal annotations.A
RowRenderer which takes a collection of CellRenderer to render cells in a row.SingleInteractiveWebViewResultWrapper<T extends org.knime.core.node.AbstractNodeView.ViewableModel & org.knime.core.node.wizard.WizardNode<REP,VAL>,REP extends org.knime.core.node.web.WebViewContent,VAL extends org.knime.core.node.web.WebViewContent>
UI-interface implementation that wraps a
InteractiveWebViewsResult.SingleInteractiveWebViewResult.UI-interface that mirrors the
SingleNodeContainer.SingleNodeContainerWrapper<W extends org.knime.core.node.workflow.SingleNodeContainer>
UI-interface implementation that wraps a
SingleNodeContainer.Thrown when a workflow snapshot is not known by the server (anymore).
The data structure of a TwinList changed from an array of strings to a more complex representation by a
ColumnFilter.The data structure of a ColumnSelection dropdown changed from a strings to a more complex representation by a
ColumnSelection.The SubNodeContainerDialogFactory creates a
NodeDialog for all the configuration nodes inside a
SubNodeContainer by parsing the DialogNodeRepresentations of those nodes and converting those to
jsonforms which is parsed by the NodeDialog page.UI-interface that mirrors the
SubNodeContainer.UI-interface implementation that wraps a
SubNodeContainer.A renderer factory that uses and returns the swing-based
DataValueRenderer-implementations.I did as best a search as i could to find a pre-existing class of this ilk (something that provides SWT related
helper methods and could find none.) Also, i named this
SWTUtilities instead of SWTUtil,
the latter which better obey the majority of the utility class names in this package, because there is already an
internal Eclipse class of that name.A class for converting table data into a single string in a format suitable to be copied into the clipboard.
A
NodeView implementation for displaying tables.A utility which temporarily created a map of renderers per column and is used to render a section of the present
table to a 2d collection of objects.
This class is used to apply a
RowRenderer to a section from/to an index in a table.Represents a view of on a table (which is not necessarily rendered as a table!).
The common Section Layout used by the Table View and Statistics View nodes
TODO: UIEXT-994 move to knime-base-views
Manages
TableView-instances.Annotate a
String setting with this in order to provide validation instructions.Used to transform string parameters from the front-end to JSON in a consistent way
Triggers when a boolean is true.
Marker-interface for all eclipse-UI related components.
A UI extension is a custom contribution to the KNIME UI.
A record representing a single control within a node dialog
Represents an undo operation.
Node triple provider with an additional update method.
This interface is used for defining any kind of update of settings values or context information (e.g.
Add this annotation to a
Credentials setting in order to display a single string input field.Annotate an
Enum setting with this in order to display them as a value switch instead of the default
(dropdown list).An implementation of
VariableSettingsWO that only adds the settings for the variables to the node settings if
necessary.Gives access to the variable settings tree.
Utilities around
VariableSettingsRO and VariableSettingsWO.Write-only settings for using and exposing other settings via flow variables.
Configuration for a
WebUI node.A builder for assembly of
WebUINodeConfigurationsThe (final) build stage in which the ports and other "optional" configurations are defined.
The build stage that requires a full description.
The build stage that requires an icon.
The build stage that requires the model settings.
The build stage that requires a short description.
WebUINodeFactory<M extends org.knime.core.node.NodeModel>
A convenience class for simple WebUI nodes, i.e., nodes making use of the
DefaultNodeSettings and
DefaultNodeDialog classes.The
NodeModel for simple WebUI nodes, see WebUINodeFactory.Utily methods relevant for the web UI.
An annotation for indicating controlling the common widget metadata of a given field.
This utility class defines defaults and registers additional annotations used to define the format of an ui element.
Extend this by a new element for each new default format of a ui element.
Workflow context information that should be available to the UI.
UI-interface implementation that wraps
WorkflowContextV2.Represents copied parts of a workflow.
Represents copied parts of a workflow including their offset.
UI-interface implementation that wraps a
WorkflowDef.Represents an in-port of a workflow (e.g.
UI-interface implementation that wraps a
WorkflowInPort.UI-interface that mirrors the
WorkflowManager.Implements the
WorkflowManagerUI interface by simply wrapping the WorkflowManager implementation.Represents a node out-port of a workflow (e.g.
UI-interface implementation that wraps a
WorkflowOutPort.UI-interface implementation that wraps a
WorkflowPersistor.Wraps another object and provides static methods to wrap and unwrap those.
The excluding or operation.