Refine search
@Override public void process(final Module module) { if (uiService == null) return; // no UI service available final UserInterface ui = uiService.getDefaultUI(); if (ui == null) return; // no default UI for (final ModuleItem<?> input : module.getInfo().inputs()) { if (!input.isAutoFill()) continue; // cannot auto-fill this input final Class<?> type = input.getType(); if (type.isAssignableFrom(ui.getClass())) { // input is a compatible UI final String name = input.getName(); module.setInput(name, ui); module.resolveInput(name); } } }
/** Creates a new module item with the same values as the given item. */ public DefaultMutableModuleItem(final ModuleInfo info, final ModuleItem<T> item) { super(info); name = item.getName(); type = item.getType(); genericType = item.getGenericType(); ioType = item.getIOType(); visibility = item.getVisibility(); required = item.isRequired(); persisted = item.isPersisted(); persistKey = item.getPersistKey(); initializer = item.getInitializer(); validater = item.getValidater(); callback = item.getCallback(); widgetStyle = item.getWidgetStyle(); minimumValue = item.getMinimumValue(); maximumValue = item.getMaximumValue(); softMinimum = item.getSoftMinimum(); softMaximum = item.getSoftMaximum(); stepSize = item.getStepSize(); columnCount = item.getColumnCount(); final List<T> itemChoices = item.getChoices(); if (itemChoices != null) choices.addAll(itemChoices); label = item.getLabel(); description = item.getDescription(); }
/** Loads the value of the given module item from persistent storage. */ private <T> void loadValue(final Module module, final ModuleItem<T> item) { // skip input that has already been resolved if (module.isInputResolved(item.getName())) return; final T prefValue = moduleService.load(item); final Class<T> type = item.getType(); final T defaultValue = item.getValue(module); final T value = getBestValue(prefValue, defaultValue, type); item.setValue(module, value); }
private String prefKey(final ModuleItem<?> item) { final String persistKey = item.getPersistKey(); return persistKey == null || persistKey.isEmpty() ? // item.getName() : persistKey; } }
/** * Gets the single unresolved {@link File} input parameter. If there is not * exactly one unresolved {@link File} input parameter, or if there are other * types of unresolved parameters, this method returns null. */ private ModuleItem<File> getFileInput(final Module module) { ModuleItem<File> result = null; for (final ModuleItem<?> input : module.getInfo().inputs()) { if (module.isInputResolved(input.getName())) continue; final Class<?> type = input.getType(); if (!File.class.isAssignableFrom(type)) { // not a File parameter; abort return null; } if (result != null) { // second File parameter; abort return null; } @SuppressWarnings("unchecked") final ModuleItem<File> fileInput = (ModuleItem<File>) input; result = fileInput; } return result; }
@Override public void process(final Module module) { if (uiService == null) return; final ModuleItem<File> fileInput = getFileInput(module); if (fileInput == null) return; final File file = fileInput.getValue(module); final String style = fileInput.getWidgetStyle(); // show file chooser dialog box final File result = uiService.chooseFile(file, style); if (result == null) { cancel(""); return; } fileInput.setValue(module, result); module.resolveInput(fileInput.getName()); }
private void assertItem(final String name, final Class<?> type, final String label, final ItemIO ioType, final boolean required, final boolean persist, final String persistKey, final String style, final Object value, final Object min, final Object max, final Object softMin, final Object softMax, final Number stepSize, final List<?> choices, final ModuleItem<?> item) { assertEquals(name, item.getName()); assertSame(type, item.getType()); assertEquals(label, item.getLabel()); assertSame(ioType, item.getIOType()); assertEquals(required, item.isRequired()); assertEquals(persist, item.isPersisted()); assertEquals(persistKey, item.getPersistKey()); assertEquals(style, item.getWidgetStyle()); assertEquals(value, item.getDefaultValue()); assertEquals(min, item.getMinimumValue()); assertEquals(max, item.getMaximumValue()); assertEquals(softMin, item.getSoftMinimum()); assertEquals(softMax, item.getSoftMaximum()); assertEquals(stepSize, item.getStepSize()); assertEquals(choices, item.getChoices()); }
@Override public void process(final Module module) { for (final ModuleItem<?> input : module.getInfo().inputs()) { if (input.isRequired() && input.getValue(module) == null) { cancel("'" + input.getName() + "' is required but unset."); } } }
@Override public void process(final Module module) { if (logService == null || moduleService == null) return; final ModuleItem<?> loggerInput = moduleService.getSingleInput(module, Logger.class); if (loggerInput == null || !loggerInput.isAutoFill()) return; String loggerName = loggerInput.getLabel(); if(loggerName == null || loggerName.isEmpty()) loggerName = module.getDelegateObject().getClass().getSimpleName(); Logger logger = logService.subLogger(loggerName); final String name = loggerInput.getName(); module.setInput(name, logger); module.resolveInput(name); }
@Override public void process(final Module module) { if (displayService == null) return; for (final ModuleItem<?> outputItem : module.getInfo().outputs()) { if (module.isOutputResolved(outputItem.getName())) continue; final Object value = outputItem.getValue(module); final String name = defaultName(outputItem); final boolean resolved = handleOutput(name, value); if (resolved) module.resolveOutput(name); } }
/** Does any needed processing, after input values have been harvested. */ @SuppressWarnings("unused") default void processResults(final InputPanel<P, W> inputPanel, final Module module) throws ModuleException { final Iterable<ModuleItem<?>> inputs = module.getInfo().inputs(); for (final ModuleItem<?> item : inputs) { final String name = item.getName(); module.resolveInput(name); } } }
private <S extends Service> void setServiceValue(final Context context, final Module module, final ModuleItem<S> input) { final S service = context.getService(input.getType()); input.setValue(module, service); module.resolveInput(input.getName()); }
@Override public void process(final Module module) { // look for single inputs that can be populated final ModuleItem<?> singleInput = getSingleInput(module, inputType); if (singleInput == null) return; // populate the value of the single input Object value = getValue(); if (value == null) return; String itemName = singleInput.getName(); value = convertService.convert(value, singleInput.getType()); module.setInput(itemName, value); module.resolveInput(itemName); }
private <T> WidgetModel addInput(final InputPanel<P, W> inputPanel, final Module module, final ModuleItem<T> item) throws ModuleException { final String name = item.getName(); final boolean resolved = module.isInputResolved(name); if (resolved) return null; // skip resolved inputs final Class<T> type = item.getType(); final WidgetModel model = widgetService.createModel(inputPanel, module, item, getObjects(type)); final Class<W> widgetType = inputPanel.getWidgetComponentType(); final InputWidget<?, ?> widget = widgetService.create(model); if (widget == null) { log.debug("No widget found for input: " + model.getItem().getName()); } if (widget != null && widget.getComponentType() == widgetType) { @SuppressWarnings("unchecked") final InputWidget<?, W> typedWidget = (InputWidget<?, W>) widget; inputPanel.addWidget(typedWidget); return model; } if (item.isRequired()) { throw new ModuleException("A " + type.getSimpleName() + " is required but none exist."); } // item is not required; we can skip it return null; }
@Override public void process(final Module module) { for (final ModuleItem<?> input : module.getInfo().inputs()) { if (!input.isAutoFill()) continue; // cannot auto-fill this input final Class<?> type = input.getType(); if (Gateway.class.isAssignableFrom(type)) { // input is a gateway @SuppressWarnings("unchecked") final ModuleItem<? extends Gateway> gatewayInput = (ModuleItem<? extends Gateway>) input; setGatewayValue(getContext(), module, gatewayInput); } } }
/** Helper method of {@link #assignInputs}. */ private void assign(final Module module, final Object arg, final ModuleItem<?> item) { if (arg != null) { final Type type = item.getGenericType(); final Object value = convert(arg, type); module.setInput(item.getName(), value); } module.resolveInput(item.getName()); }
@Override public void process(final Module module) { // assign singleton RoiManager to single RoiManager input final ModuleItem<RoiManager> roiManagerInput = moduleService.getSingleInput( module, RoiManager.class); if (roiManagerInput != null) { RoiManager roiManager; if (roiManagerInput.isRequired()) { roiManager = RoiManager.getRoiManager(); } else { roiManager = RoiManager.getInstance(); } if (roiManager == null) return; module.setInput(roiManagerInput.getName(), roiManager); module.resolveInput(roiManagerInput.getName()); } } }
/** * Extract the Axis from the {@link Dataset}. * * @param model A {@link WidgetModel} * @return The Axis of the {@link Dataset} or null if no {@link Dataset} was * found. */ private TypedAxis[] extractAxis(final WidgetModel model) { final Module module = model.getModule(); for (final ModuleItem<?> moduleItem : module.getInfo().inputs()) { if (TypedSpace.class.isAssignableFrom(moduleItem.getType())) { final TypedSpace<?> space = (TypedSpace<?>) moduleItem.getValue(module); final TypedAxis[] axis = new TypedAxis[space.numDimensions()]; for (int i = 0; i < space.numDimensions(); i++) { axis[i] = space.axis(i); } return axis; } } return null; }