/** * Sets the module's projected object collection. * * @param moduleObjects * the projected object collection. */ public void setModuleObjects(Collection<?> moduleObjects) { if (ObjectUtils.equals(this.moduleObjects, moduleObjects)) { return; } Object oldValue = getModuleObjects(); this.moduleObjects = moduleObjects; firePropertyChange("moduleObjects", oldValue, getModuleObjects()); }
/** * {@inheritDoc} */ @Override public String getIconImageURL() { String iconImageUrl = super.getIconImageURL(); if (iconImageUrl == null) { iconImageUrl = getElementComponentDescriptor().getIconImageURL(); setIconImageURL(iconImageUrl); } return iconImageUrl; } }
/** * Mobile bean collection module views only support page views as element views * descriptors. * <p/> * {@inheritDoc} */ @Override public IMobilePageViewDescriptor getElementViewDescriptor() { return (IMobilePageViewDescriptor) super.getElementViewDescriptor(); }
/** * Removes an element from the the module's projected object collection. * * @param element * the element to remove. */ public void removeFromModuleObjects(Object element) { if (getModuleObjects() != null) { List<Object> newModuleObjects; newModuleObjects = new ArrayList<>(getModuleObjects()); newModuleObjects.remove(element); setModuleObjects(newModuleObjects); } }
public IViewDescriptor getViewDescriptor() { if (cachedViewDescriptor == null) { IViewDescriptor projectedViewDescriptor = getProjectedViewDescriptor(); IViewDescriptor moduleObjectsView = BasicCollectionViewDescriptor.extractMainCollectionView( projectedViewDescriptor); BeanCollectionModuleDescriptor moduleDescriptor = getDescriptor(); ((BasicViewDescriptor) moduleObjectsView).setModelDescriptor(moduleDescriptor.getPropertyDescriptor(BeanCollectionModule.MODULE_OBJECTS)); BasicBorderViewDescriptor moduleViewDescriptor = new BasicBorderViewDescriptor(); if (isDetailViewIncluded()) { BasicTabViewDescriptor wrapperTabViewDescriptor = new BasicTabViewDescriptor(); wrapperTabViewDescriptor.setCascadingModels(true); BasicViewDescriptor elementViewDescriptor = (BasicViewDescriptor) getElementViewDescriptor(); if (getNavigateModuleObjectsActionList() != null) { ActionMap elementViewActionMap = elementViewDescriptor.getActionMap(); elementViewDescriptor = elementViewDescriptor.clone(); actionMapWithNavigation.setParentActionMaps(Arrays.asList(elementViewActionMap)); actionMapWithNavigation.setActionLists(Arrays.asList(getNavigateModuleObjectsActionList())); elementViewDescriptor.setActionMap(actionMapWithNavigation);
private Collection<Module> cleanComponentsFromModules(Module module, Collection<?> componentsToDelete) { if (module instanceof BeanCollectionModule) { List<?> moduleObjects = ((BeanCollectionModule) module).getModuleObjects(); if (moduleObjects != null) { for (Object componentToDelete : componentsToDelete) { if (moduleObjects.contains(componentToDelete)) { ((BeanCollectionModule) module).removeFromModuleObjects(componentToDelete); } } } } Collection<Module> modulesToRemove = new ArrayList<>(); List<Module> subModules = module.getSubModules(); if (subModules != null) { for (Module subModule : subModules) { if (subModule instanceof BeanModule && componentsToDelete.contains( ((BeanModule) subModule).getModuleObject())) { ((BeanModule) subModule).setModuleObject(null); modulesToRemove.add(subModule); } Collection<Module> grandSubModulesToRemove = cleanComponentsFromModules(subModule, componentsToDelete); removeSubModules(subModule, grandSubModulesToRemove); } } return modulesToRemove; }
private void prepareModuleCards(Map<String, IViewDescriptor> moduleCards, List<Module> modules, IModuleViewDescriptorFactory moduleDescriptorViewFactory) { if (modules != null) { for (Module module : modules) { if (module.getProjectedViewDescriptor() != null) { moduleCards.put(module.getName(), moduleDescriptorViewFactory .createProjectedViewDescriptor(module)); if (module instanceof BeanCollectionModule) { BeanModule fakeBeanModule = new BeanModule(); fakeBeanModule .setProjectedViewDescriptor(((BeanCollectionModule) module) .getElementViewDescriptor()); fakeBeanModule .setComponentDescriptor(((BeanCollectionModule) module) .getElementComponentDescriptor()); moduleCards.put(module.getName() + ELEMENT_SUFFIX, moduleDescriptorViewFactory .createProjectedViewDescriptor(fakeBeanModule)); } } prepareModuleCards(moduleCards, module.getSubModules(), moduleDescriptorViewFactory); } } } }
/** * {@inheritDoc} * * @return the icon */ @Override public Icon getIcon() { Icon icon = super.getIcon(); if (icon == null) { icon = getElementComponentDescriptor().getIcon(); setIcon(icon); } return icon; }
/** * {@inheritDoc} * * @param backendController * the backend controller * @return the boolean */ @Override protected boolean isLocallyDirty(IBackendController backendController) { boolean locallyDirty = backendController.isAnyDirtyInDepth(getModuleObjects()); return locallyDirty; }
/** * Is sub module sticky. Never consider a bean module sticky if it holds a component that is a detail of the * collection module. * * @param subModule * the sub module * @return the boolean */ @Override public boolean isSubModuleSticky(Module subModule) { if (!isStarted()) { if (subModule instanceof BeanModule) { IComponentDescriptor<?> subModuleComponentDescriptor = ((BeanModule) subModule).getComponentDescriptor(); IComponentDescriptor<?> elementComponentDescriptor = getElementComponentDescriptor(); if (subModuleComponentDescriptor != null && elementComponentDescriptor != null && subModuleComponentDescriptor .getComponentContract().isAssignableFrom(elementComponentDescriptor.getComponentContract())) { return false; } } } return super.isSubModuleSticky(subModule); }
/** * Gets the module descriptor. * * @return the module descriptor. */ protected BeanCollectionModuleDescriptor getDescriptor() { return new BeanCollectionModuleDescriptor(getElementComponentDescriptor()); }
private void removeModulesFromParent(Module parentModule, Collection<Module> subModulesToRemove) { parentModule.removeSubModules(subModulesToRemove); for (Module module : subModulesToRemove) { if (module instanceof BeanModule) { ((BeanModule) module).setModuleObject(null); } else if (module instanceof BeanCollectionModule) { ((BeanCollectionModule) module).setModuleObjects(null); } } } }
private static void removeFromSubModules(Module parentModule, Object removedObject) { if (parentModule != null && parentModule.getSubModules() != null) { for (Module module : new ArrayList<>(parentModule.getSubModules())) { if (module instanceof BeanModule && removedObject.equals(((BeanModule) module).getModuleObject())) { parentModule.removeSubModule(module); } } } if (parentModule instanceof BeanCollectionModule) { ((BeanCollectionModule) parentModule) .removeFromModuleObjects(removedObject); } }
/** * Mobile bean collection module views only support list views as projected view * descriptors. * <p/> * {@inheritDoc} */ @Override public IListViewDescriptor getProjectedViewDescriptor() { return (IListViewDescriptor) super.getProjectedViewDescriptor(); }
/** * {@inheritDoc} * * @return the filterable bean collection module */ @Override public FilterableBeanCollectionModule clone() { FilterableBeanCollectionModule clone = (FilterableBeanCollectionModule) super.clone(); clone.filterComponentTracker = new FilterComponentTracker(clone); if (filter != null) { clone.setFilter(filter.clone()); } return clone; }
/** * Adds an element to the module's projected object collection. * * @param element * the element to add. */ public void addToModuleObjects(Object element) { List<Object> newModuleObjects; if (getModuleObjects() != null) { newModuleObjects = new ArrayList<>(getModuleObjects()); } else { newModuleObjects = new ArrayList<>(); } newModuleObjects.add(element); setModuleObjects(newModuleObjects); }
private void completeEntitiesToReload(Module module, List<IEntity> entitiesToReload) { if (module instanceof BeanCollectionModule && ((BeanCollectionModule) module).getModuleObjects() != null) { for (Object moduleObject : ((BeanCollectionModule) module).getModuleObjects()) { if (moduleObject instanceof IEntity) { entitiesToReload.add((IEntity) moduleObject); } } } else if (module instanceof BeanModule) { Object moduleObject = ((BeanModule) module).getModuleObject(); if (moduleObject instanceof IEntity) { entitiesToReload.add((IEntity) moduleObject); } } if (module.getSubModules() != null) { for (Module subModule : module.getSubModules()) { completeEntitiesToReload(subModule, entitiesToReload); } } } }
if (module instanceof BeanCollectionModule) { IComponentDescriptor<Object> componentDescriptor = ((BeanCollectionModule) module) .getElementComponentDescriptor(); if (componentDescriptor == null && projectedViewDescriptor instanceof ICollectionViewDescriptor
/** * Fills the context with the filter reference descriptor. * <p> * {@inheritDoc} */ @Override public boolean execute(IActionHandler actionHandler, Map<String, Object> context) { IModelValueConnector filterModelConnector = (IModelValueConnector) getModuleConnector( context).getChildConnector("filter"); context.put(ActionContextConstants.QUERY_MODEL_CONNECTOR, filterModelConnector); context.put(ActionContextConstants.COMPONENT_REF_DESCRIPTOR, filterModelConnector.getModelDescriptor()); BeanCollectionModule beanCollectionModule = (BeanCollectionModule) getModuleConnector( context).getConnectorValue(); beanCollectionModule.setModuleObjects(null); return super.execute(actionHandler, context); }
@Override public boolean execute(IActionHandler actionHandler, Map<String, Object> context) { Object model = getModel(context); if (model instanceof IEntity && !((IEntity) model).isPersistent()) { Module currentModule = getModule(context); if (currentModule instanceof BeanCollectionModule) { ((BeanCollectionModule) currentModule).removeFromModuleObjects(model); } actionHandler.execute(backPageAction, context); } return super.execute(actionHandler, context); } }