/** * {@inheritDoc} */ public boolean execute(@SuppressWarnings("unused") IActionHandler actionHandler, Map<String, Object> context) { Object previousActionResult = context .get(ActionContextConstants.ACTION_PARAM); IValueConnector connector = (IValueConnector) context .get(connectorActionContextKey); // the following will force a connector value change event. // connector.setConnectorValue(null); connector.setConnectorValue(previousActionResult); return true; }
/** * {@inheritDoc} */ @Override protected String getActionText() { if (renderingConnector != null) { if (renderingConnector.getConnectorValue() == null) { return ""; } return renderingConnector.getConnectorValue().toString(); } return super.getActionText(); }
/** * Given a connector, this method loops upward to the parent/child * relationship to determine the first connector of the hierarchy. * * @param connector * the connector to look the root parent connector for. * @return the root parent connector. */ public static IValueConnector getRootConnector(IValueConnector connector) { if (connector == null) { return null; } IValueConnector parentConnector = connector; while (parentConnector.getParentConnector() != null) { parentConnector = parentConnector.getParentConnector(); } return parentConnector; } }
/** * Retrieves a connector complete path following the parent/child * relationship. * * @param connector * the connector to look the tree path for. * @return the list of connector identifiers from the root connector to the * looked-up connector. */ public static List<String> getPathToConnector(IValueConnector connector) { if (connector == null) { return null; } List<String> path = new ArrayList<>(); IValueConnector parentConnector = connector; while (parentConnector != null) { path.add(parentConnector.getId()); parentConnector = parentConnector.getParentConnector(); } Collections.reverse(path); return path; }
/** * Attach the necessary listeners to the value connector so that adequate * notifications get sent to the remote client side. * * @param connector * the connector to attach listeners to. */ protected void attachListeners(IValueConnector connector) { connector.addPropertyChangeListener(IValueConnector.READABLE_PROPERTY, readabilityListener); connector.addPropertyChangeListener(IValueConnector.WRITABLE_PROPERTY, writabilityListener); if (connector instanceof ICollectionConnector) { connector.addValueChangeListener(collectionConnectorValueChangeListener); ((ICollectionConnector) connector).addSelectionChangeListener(selectionChangeListener); } else if (connector instanceof IRenderableCompositeValueConnector) { if (((IRenderableCompositeValueConnector) connector).getRenderingConnector() != null) { ((IRenderableCompositeValueConnector) connector).getRenderingConnector().addValueChangeListener( renderingConnectorValueChangeListener); } } else if (connector instanceof IFormattedValueConnector) { connector.addValueChangeListener(formattedConnectorValueChangeListener); } else { connector.addValueChangeListener(valueChangeListener); } }
IValueConnector selectableConnector = getViewConnector(viewPath, context); while (selectableConnector != null && !(selectableConnector instanceof ISelectable)) { if (selectableConnector.getParentConnector() != null) { selectableConnector = selectableConnector.getParentConnector(); } else { selectableConnector = selectableConnector.getModelConnector();
if (columnViewDescriptor.getReadabilityGates() != null) { for (IGate gate : columnViewDescriptor.getReadabilityGates()) { columnConnector.addReadabilityGate(gate.clone()); columnConnector.addWritabilityGate(gate.clone()); columnConnector.setLocallyWritable(!columnViewDescriptor.isReadOnly()); } catch (SecurityException ex) { .getActions().get(0))); if (editorView.getConnector().getParentConnector() == null) { editorView.getConnector().setParentConnector(connector);
IValueConnector oldModelConnector = getModelConnector(); if (oldModelConnector != null) { oldModelConnector.removeValueChangeListener(this); removeValueChangeListener(oldModelConnector); if (modelReadabilityListener != null) { oldModelConnector.removePropertyChangeListener( IValueConnector.READABLE_PROPERTY, modelReadabilityListener); oldModelConnector.removePropertyChangeListener( IValueConnector.WRITABLE_PROPERTY, modelWritabilityListener); getModelConnector().getConnectorValue()); if (evt.needsFiring()) { valueChange(evt); getModelConnector().addValueChangeListener(this); addValueChangeListener(getModelConnector()); if (modelReadabilityListener == null) { getModelConnector().addPropertyChangeListener( IValueConnector.READABLE_PROPERTY, modelReadabilityListener); getModelConnector().addPropertyChangeListener( IValueConnector.WRITABLE_PROPERTY, modelWritabilityListener); } else {
if (propertyViewDescriptor.getReadabilityGates() != null) { for (IGate gate : propertyViewDescriptor.getReadabilityGates()) { propertyView.getConnector().addReadabilityGate(gate.clone()); propertyView.getConnector().addWritabilityGate(gate.clone()); propertyView.getConnector().setLocallyWritable( !propertyViewDescriptor.isReadOnly()); JLabel propertyLabel = createPropertyLabel(propertyDescriptor,
/** * {@inheritDoc} */ public Collection<String> getChildConnectorKeys() { if (toStringPropertyConnector != null) { return Collections.singleton(toStringPropertyConnector.getId()); } return null; }
editorView.getConnector().resetReadabilityGates(); editorView.getConnector().resetWritabilityGates(); for (IValueChangeListener listener : editorView.getConnector().getValueChangeListeners()) { if (listener instanceof ConnectorActionAdapter) { editorView.getConnector().removeValueChangeListener(listener); if (editorView.getConnector().getParentConnector() == null) { editorView.getConnector().setParentConnector(connector);
/** * This is a utility method which is able to retrieve the model connector this * action has been executed on from its context. It uses well-known context * keys of the action context which are: * <ul> * <li> <code>ActionContextConstants.VIEW_CONNECTOR</code> to get the model * value connector of the connector hierarchy. * </ul> * <p> * The returned connector mainly serves for retrieving the domain object the * action has to be triggered on. * * @param context * the action context. * @return the value connector this model action was triggered on. */ public IValueConnector getModelConnector(Map<String, Object> context) { return ((IValueConnector) context .get(ActionContextConstants.VIEW_CONNECTOR)).getModelConnector(); }
if (viewConnector.getModelConnector() == modelConnector) { return; viewConnector.setModelConnector(modelConnector); if (viewConnector instanceof ICompositeValueConnector) { if (modelConnector == null || modelConnector instanceof ICompositeValueConnector) { } else { throw new IllegalArgumentException("Trying to bind a composite view to a non-composite model for property : " + modelConnector.getModelDescriptor().getName()); viewConnector.boundAsView(); if (modelConnector != null) { modelConnector.boundAsModel();
IView<SComponent> editorView = createView(columnViewDescriptor, actionHandler, locale); editorView.getConnector().resetReadabilityGates(); editorView.getConnector().resetWritabilityGates(); if (editorView.getConnector().getParentConnector() == null) { editorView.getConnector().setParentConnector(connector);
viewComponent.setMainAction(editAction); editAction.setEnabled(view.getConnector().isWritable()); view.getConnector().addPropertyChangeListener(IValueConnector.WRITABLE_PROPERTY, new PropertyChangeListener() { @Override public void propertyChange(PropertyChangeEvent evt) {
private void bindChildRowConnector(int row) { ICompositeValueConnector rowConnector = (ICompositeValueConnector) collectionConnector .getChildConnector(row); rowConnector .addConnectorValueChangeListener(getChildRowConnectorListener(row)); for (int col = 0; col < columnConnectorKeys.size(); col++) { IValueConnector cellConnector = rowConnector .getChildConnector(columnConnectorKeys.get(col)); if (cellConnector instanceof IRenderableCompositeValueConnector && ((IRenderableCompositeValueConnector) cellConnector) .getRenderingConnector() != null) { ((IRenderableCompositeValueConnector) cellConnector) .getRenderingConnector().addConnectorValueChangeListener( getChildCellConnectorListener(row, col)); } else { CellConnectorListener listener = getChildCellConnectorListener(row, col); cellConnector.addConnectorValueChangeListener(listener); cellConnector.addPropertyChangeListener(listener); } } }
/** * {@inheritDoc} */ @Override public boolean isCellEditable(int rowIndex, int columnIndex) { // Editability is only handled at cell level //collectionConnector.isWritable() // && collectionConnector.getChildConnector(rowIndex).isWritable() return getConnectorAt(rowIndex, columnIndex).isWritable(); }
/** * {@inheritDoc} */ @Override public void bind(IValueConnector masterConnector, final IValueConnector detailConnector) { if (masterConnector instanceof IItemSelectable) { ((IItemSelectable) masterConnector) .addItemSelectionListener(new BoundConnectorSelectionListener( detailConnector)); } else { // Do not simply add the detail connector since it will propagate // writability of the master to the detail which is wrong. see bug#342. // } else if (masterConnector instanceof ICompositeValueConnector) { // ((ICompositeValueConnector) masterConnector) // .addChildConnector(detailConnector); mvcBinder.bind(detailConnector, masterConnector.getModelConnector()); masterConnector.addPropertyChangeListener( IValueConnector.MODEL_CONNECTOR_PROPERTY, new BoundConnectorModelListener(detailConnector)); } }
for (IValueChangeListener listener : columnConnector.getValueChangeListeners()) { if (listener instanceof ConnectorActionAdapter) { columnConnector.removeValueChangeListener(listener); columnConnector.addValueChangeListener( new ConnectorActionAdapter<>(columnViewDescriptor.getAction(), getActionFactory(), actionHandler, view)); columnConnector.setLocallyWritable(false); } else if (columnViewDescriptor.isReadOnlyExplicitlyConfigured()) { columnConnector.setLocallyWritable(!columnViewDescriptor.isReadOnly());
+ id + "]."); modelConnector.setSecurityHandler(securityHandler); if (modelDescriptor instanceof IGateAccessible) { boolean writable = !((IGateAccessible) modelDescriptor) modelConnector.setLocallyWritable(false); } else if (((IGateAccessible) modelDescriptor).isReadOnlyExplicitlyConfigured()) { modelConnector.setLocallyWritable(!((IGateAccessible) modelDescriptor).isReadOnly()); if (!(gate instanceof ISecurable) || securityHandler.isAccessGranted((ISecurable) gate)) { modelConnector.addReadabilityGate(gate.clone()); if (!(gate instanceof ISecurable) || securityHandler.isAccessGranted((ISecurable) gate)) { modelConnector.addWritabilityGate(gate.clone());