| /** |
| * |
| * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation |
| * |
| * |
| * This copyright notice shows up in the generated Java code |
| * |
| */ |
| |
| package org.eclipse.osbp.xtext.menu.jvmmodel |
| |
| import com.vaadin.ui.Accordion |
| import com.vaadin.ui.Component |
| import com.vaadin.ui.MenuBar |
| import com.vaadin.ui.TabSheet |
| import com.vaadin.ui.VerticalLayout |
| import java.util.HashMap |
| import java.util.Locale |
| import javax.annotation.PostConstruct |
| import javax.inject.Inject |
| import javax.inject.Named |
| import org.eclipse.e4.core.contexts.IContextFunction |
| import org.eclipse.e4.core.contexts.IEclipseContext |
| import org.eclipse.e4.core.di.annotations.Optional |
| import org.eclipse.osbp.bpm.api.IBPMEngine |
| import org.eclipse.osbp.bpm.api.IBlipBPMFunctionProvider |
| import org.eclipse.osbp.runtime.common.event.IEventDispatcher |
| import org.eclipse.osbp.ui.api.contextfunction.IUserMenuProvider |
| import org.eclipse.osbp.ui.api.contextfunction.IVaadinDialogProvider |
| import org.eclipse.osbp.ui.api.contextfunction.IViewEmbeddedProvider |
| import org.eclipse.osbp.ui.api.menu.IMenuItemHandler |
| import org.eclipse.osbp.ui.api.metadata.IDSLMetadataService |
| import org.eclipse.osbp.ui.api.perspective.IPerspectiveProvider |
| import org.eclipse.osbp.ui.api.themes.IThemeResourceService |
| import org.eclipse.osbp.ui.api.user.IUser |
| import org.eclipse.osbp.ui.api.useraccess.IUserAccessService |
| import org.eclipse.osbp.utils.annotation.CommonUtils |
| import org.eclipse.osbp.utils.vaadin.bpmn.BpmnWindow |
| import org.eclipse.osbp.vaaclipse.api.VaadinExecutorService |
| import org.eclipse.osbp.xtext.menu.MenuCategory |
| import org.eclipse.osbp.xtext.menu.MenuPackage |
| import org.eclipse.osbp.xtext.menu.common.UserMenuItem |
| import org.eclipse.xtext.Constants |
| import org.eclipse.xtext.common.types.JvmDeclaredType |
| import org.eclipse.xtext.common.types.JvmField |
| import org.eclipse.xtext.common.types.JvmGenericType |
| import org.eclipse.xtext.common.types.JvmTypeReference |
| import org.eclipse.xtext.common.types.JvmVisibility |
| import org.eclipse.xtext.naming.IQualifiedNameProvider |
| import org.eclipse.xtext.xbase.jvmmodel.AbstractModelInferrer |
| import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor |
| import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder |
| import org.slf4j.Logger |
| import org.vaadin.hene.popupbutton.PopupButton |
| import org.vaadin.hene.popupbutton.PopupButton.PopupVisibilityEvent |
| import org.vaadin.hene.popupbutton.PopupButton.PopupVisibilityListener |
| |
| class MenuDslJvmModelInferrer extends AbstractModelInferrer { |
| @Inject extension JvmTypesBuilder |
| @Inject extension IQualifiedNameProvider |
| @Inject |
| @Named(Constants.FILE_EXTENSIONS) String fileExtension |
| @Inject extension CommonUtils |
| |
| var String binderClassName = "" |
| var String contextClassName = "" |
| var String clsName = "" |
| var flagTreeMenu = false |
| |
| def dispatch void infer(MenuPackage pkg, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) { |
| clsName = pkg.eResource.URI.lastSegment.replace("."+fileExtension,"").toFirstUpper+fileExtension.toFirstUpper |
| val cls = pkg.toClass(pkg.name+"."+clsName) |
| cls.superTypes.add(_typeReferenceBuilder.typeRef(IUserMenuProvider)) |
| cls.superTypes.add(_typeReferenceBuilder.typeRef(IUser.UserLocaleListener)) |
| cls.superTypes.add(_typeReferenceBuilder.typeRef(PopupVisibilityListener)) |
| acceptor.accept(cls, |
| [ |
| it.toFields(pkg) |
| it.toInjectedFields(pkg) |
| it.toConstructor(pkg) |
| it.toOperations(pkg) |
| ]) |
| // the context function class |
| contextClassName = pkg.name+"."+clsName+"ContextFunction" |
| val contextCls = pkg.toClass(contextClassName) |
| contextCls.getSuperTypes().add(_typeReferenceBuilder.typeRef(IContextFunction)) |
| contextCls.simpleName = contextCls.simpleName.toFirstUpper |
| acceptor.accept(contextCls, |
| [ |
| var annotationRef = _annotationTypesBuilder.annotationRef(typeof(org.osgi.service.component.annotations.Component)) |
| annotationRef.addAnnAttr(pkg, "service", _typeReferenceBuilder.typeRef(IContextFunction) as JvmTypeReference) |
| var propContent = '''«IContextFunction.SERVICE_CONTEXT_KEY»=Menu''' |
| annotationRef.addAnnAttr(pkg, "property", propContent) |
| annotations += annotationRef |
| packageName = pkg.fullyQualifiedName.toString |
| it.toContextOperations(pkg) |
| ]) |
| |
| } |
| |
| def void toContextOperations(JvmGenericType type, MenuPackage pkg) { |
| // compute override |
| type.members += pkg.toMethod("compute", _typeReferenceBuilder.typeRef(Object), [ |
| annotations += _annotationTypesBuilder.annotationRef(Override) |
| visibility = JvmVisibility.PUBLIC |
| parameters += pkg.toParameter("context", _typeReferenceBuilder.typeRef(IEclipseContext)) |
| parameters += pkg.toParameter("contextKey", _typeReferenceBuilder.typeRef(String)) |
| body = [append( |
| ''' |
| MApplication application = context.get(MApplication.class); |
| IEclipseContext appCtx = application.getContext(); |
| IUserMenuProvider provider = ContextInjectionFactory.make(«clsName».class, appCtx); |
| appCtx.set(IUserMenuProvider.class, provider); |
| return provider;''')] |
| ]) |
| |
| } |
| |
| def void toInjectedFields(JvmDeclaredType type, MenuPackage pkg) { |
| pkg.categories.forEach[ |
| it.createInjects(type, pkg) |
| ] |
| } |
| |
| def void createInjects(MenuCategory category, JvmDeclaredType type, MenuPackage pkg) { |
| var JvmField field = null |
| if(category.hasTable || category.hasDialog) { |
| var name = "" |
| var list = <String>newArrayList |
| if (category.hasTable) { |
| name = category.table.name |
| } else if(category.hasDialog) { |
| name = category.dialog.name |
| } |
| if ((name !== null) && !name.isEmpty) { |
| list.add(name.toFirstUpper) |
| val annotationRef = _annotationTypesBuilder.annotationRef(Named) |
| annotationRef.addStringValuesToAnnotation(list) |
| field = pkg.toField(name.toFirstLower, _typeReferenceBuilder.typeRef(IViewEmbeddedProvider)) [annotations += _annotationTypesBuilder.annotationRef(Inject) annotations += annotationRef] |
| if (field !== null) { |
| field.visibility = JvmVisibility::PRIVATE |
| type.members += field |
| } |
| } |
| } |
| } |
| |
| def void toConstructor(JvmDeclaredType type, MenuPackage pkg) { |
| type.members += pkg.toConstructor([ |
| annotations += _annotationTypesBuilder.annotationRef(Inject) |
| body = [ append('''''')] |
| ]) |
| } |
| |
| def void toFields(JvmGenericType type, MenuPackage pkg) { |
| var JvmField field = null |
| // create logger |
| field = pkg.toField("log", _typeReferenceBuilder.typeRef(Logger))[setInitializer([append('''org.slf4j.LoggerFactory.getLogger("menu")''')])] |
| field.static = true |
| type.members += field |
| field = pkg.toField("themeResourceService", _typeReferenceBuilder.typeRef(IThemeResourceService)) [annotations += _annotationTypesBuilder.annotationRef(Inject)] |
| type.members += field |
| field = pkg.toField("userAccessService", _typeReferenceBuilder.typeRef(IUserAccessService)) [annotations += _annotationTypesBuilder.annotationRef(Inject)] |
| type.members += field |
| field = pkg.toField("dslMetadataService", _typeReferenceBuilder.typeRef(IDSLMetadataService)) [annotations += _annotationTypesBuilder.annotationRef(Inject)] |
| type.members += field |
| field = pkg.toField("eventDispatcher", _typeReferenceBuilder.typeRef(IEventDispatcher))[annotations += _annotationTypesBuilder.annotationRef(Inject)] |
| type.members += field |
| field = pkg.toField("perspectiveProvider", _typeReferenceBuilder.typeRef(IPerspectiveProvider))[annotations += _annotationTypesBuilder.annotationRef(Inject)] |
| type.members += field |
| field = pkg.toField("user", _typeReferenceBuilder.typeRef(IUser)) [annotations += _annotationTypesBuilder.annotationRef(Inject)] |
| type.members += field |
| field = pkg.toField("locale", _typeReferenceBuilder.typeRef(Locale)) |
| type.members += field |
| field = pkg.toField("bpmEngine", _typeReferenceBuilder.typeRef(IBPMEngine)) [ |
| annotations += _annotationTypesBuilder.annotationRef(Inject) |
| annotations += _annotationTypesBuilder.annotationRef(Optional) |
| ] |
| type.members += field |
| |
| field = pkg.toField("selectedMap", _typeReferenceBuilder.typeRef(HashMap, _typeReferenceBuilder.typeRef(Accordion), _typeReferenceBuilder.typeRef(Component))) |
| type.members += field |
| field = pkg.toField("menuComponent", _typeReferenceBuilder.typeRef(VerticalLayout)) |
| type.members += field |
| field = pkg.toField("designerText", _typeReferenceBuilder.typeRef(String)) |
| type.members += field |
| field = pkg.toField("designmodeText", _typeReferenceBuilder.typeRef(String)) |
| type.members += field |
| field = pkg.toField("undoText", _typeReferenceBuilder.typeRef(String)) |
| type.members += field |
| field = pkg.toField("redoText", _typeReferenceBuilder.typeRef(String)) |
| type.members += field |
| field = pkg.toField("newText", _typeReferenceBuilder.typeRef(String)) |
| type.members += field |
| field = pkg.toField("changeText", _typeReferenceBuilder.typeRef(String)) |
| type.members += field |
| field = pkg.toField("exportText", _typeReferenceBuilder.typeRef(String)) |
| type.members += field |
| field = pkg.toField("downloadText", _typeReferenceBuilder.typeRef(String)) |
| type.members += field |
| |
| field = pkg.toField("context", _typeReferenceBuilder.typeRef(IEclipseContext))[ |
| annotations += _annotationTypesBuilder.annotationRef(Inject)] |
| type.members += field |
| |
| field = pkg.toField("designModeHandler", _typeReferenceBuilder.typeRef(IMenuItemHandler))[annotations += _annotationTypesBuilder.annotationRef(Inject) annotations += _annotationTypesBuilder.annotationRef(Optional) annotations += _annotationTypesBuilder.annotationRef(Named, "DesignModeHandler")] |
| type.members += field |
| field = pkg.toField("designerUndoHandler", _typeReferenceBuilder.typeRef(IMenuItemHandler))[annotations += _annotationTypesBuilder.annotationRef(Inject) annotations += _annotationTypesBuilder.annotationRef(Optional) annotations += _annotationTypesBuilder.annotationRef(Named, "DesignerUndoHandler")] |
| type.members += field |
| field = pkg.toField("designerRedoHandler", _typeReferenceBuilder.typeRef(IMenuItemHandler))[annotations += _annotationTypesBuilder.annotationRef(Inject) annotations += _annotationTypesBuilder.annotationRef(Optional) annotations += _annotationTypesBuilder.annotationRef(Named, "DesignerRedoHandler")] |
| type.members += field |
| field = pkg.toField("newPerspectiveHandler", _typeReferenceBuilder.typeRef(IMenuItemHandler))[annotations += _annotationTypesBuilder.annotationRef(Inject) annotations += _annotationTypesBuilder.annotationRef(Optional) annotations += _annotationTypesBuilder.annotationRef(Named, "NewPerspectiveHandler")] |
| type.members += field |
| field = pkg.toField("changePerspectiveHandler", _typeReferenceBuilder.typeRef(IMenuItemHandler))[annotations += _annotationTypesBuilder.annotationRef(Inject) annotations += _annotationTypesBuilder.annotationRef(Optional) annotations += _annotationTypesBuilder.annotationRef(Named, "ChangePerspectiveHandler")] |
| type.members += field |
| field = pkg.toField("exportPerspectiveHandler", _typeReferenceBuilder.typeRef(IMenuItemHandler))[annotations += _annotationTypesBuilder.annotationRef(Inject) annotations += _annotationTypesBuilder.annotationRef(Optional) annotations += _annotationTypesBuilder.annotationRef(Named, "ExportPerspectiveHandler")] |
| type.members += field |
| field = pkg.toField("downloadPerspectiveHandler", _typeReferenceBuilder.typeRef(IMenuItemHandler))[annotations += _annotationTypesBuilder.annotationRef(Inject) annotations += _annotationTypesBuilder.annotationRef(Optional) annotations += _annotationTypesBuilder.annotationRef(Named, "DownloadPerspectiveHandler")] |
| type.members += field |
| field = pkg.toField("blip", _typeReferenceBuilder.typeRef(IBlipBPMFunctionProvider)) [annotations += _annotationTypesBuilder.annotationRef(Inject)] |
| type.members += field |
| field = pkg.toField("tabs", |
| _typeReferenceBuilder.typeRef(HashMap, _typeReferenceBuilder.typeRef(TabSheet.Tab), _typeReferenceBuilder.typeRef(Pair, _typeReferenceBuilder.typeRef(String), _typeReferenceBuilder.typeRef(String)))) |
| type.members += field |
| field = pkg.toField("items", |
| _typeReferenceBuilder.typeRef(HashMap, _typeReferenceBuilder.typeRef(UserMenuItem), _typeReferenceBuilder.typeRef(String))) |
| type.members += field |
| field = pkg.toField("userFilter", _typeReferenceBuilder.typeRef(IVaadinDialogProvider)) [annotations += _annotationTypesBuilder.annotationRef(Inject) annotations += _annotationTypesBuilder.annotationRef(Named, "UserFilter")] |
| type.members += field |
| field = pkg.toField("keyBinding", _typeReferenceBuilder.typeRef(IVaadinDialogProvider)) [annotations += _annotationTypesBuilder.annotationRef(Inject) annotations += _annotationTypesBuilder.annotationRef(Named, "KeyBindingDialog")] |
| type.members += field |
| field = pkg.toField("systemSettings", _typeReferenceBuilder.typeRef(IVaadinDialogProvider)) [annotations += _annotationTypesBuilder.annotationRef(Inject) annotations += _annotationTypesBuilder.annotationRef(Named, "SystemSettings")] |
| type.members += field |
| field = pkg.toField("reportPrinter", _typeReferenceBuilder.typeRef(IVaadinDialogProvider)) [annotations += _annotationTypesBuilder.annotationRef(Inject) annotations += _annotationTypesBuilder.annotationRef(Named, "ReportPrinterDialog")] |
| type.members += field |
| field = pkg.toField("executorService", _typeReferenceBuilder.typeRef(VaadinExecutorService)) [annotations += _annotationTypesBuilder.annotationRef(Inject)] |
| type.members += field |
| field = pkg.toField("enabledUpdaters", _typeReferenceBuilder.typeRef(HashMap, _typeReferenceBuilder.typeRef(MenuBar.MenuItem), _typeReferenceBuilder.typeRef(Runnable)))[setInitializer([append('''new HashMap<>()''')])] |
| type.members += field |
| field = pkg.toField("menuItems", _typeReferenceBuilder.typeRef(HashMap, _typeReferenceBuilder.typeRef(IMenuItemHandler), _typeReferenceBuilder.typeRef(MenuBar.MenuItem)))[setInitializer([append('''new HashMap<>()''')])] |
| type.members += field |
| field = pkg.toField("bpmnWindow", _typeReferenceBuilder.typeRef(BpmnWindow)) |
| type.members += field |
| } |
| |
| def void toOperations(JvmDeclaredType type, MenuPackage pkg) { |
| // init |
| type.members += pkg.toMethod("init", _typeReferenceBuilder.typeRef(Void::TYPE), [ |
| annotations += _annotationTypesBuilder.annotationRef(PostConstruct) |
| body = [ append('''«pkg.init»''')] |
| ]) |
| // create menu |
| type.members += pkg.toMethod("createMenu", _typeReferenceBuilder.typeRef(VerticalLayout), [ |
| body = [ append('''«pkg.createMenu»''')] |
| ]) |
| // setIcon |
| type.members += pkg.toMethod("setIcon", _typeReferenceBuilder.typeRef(Void::TYPE), [ |
| parameters += pkg.toParameter("accordion", _typeReferenceBuilder.typeRef(Accordion)) |
| parameters += pkg.toParameter("open", _typeReferenceBuilder.typeRef(boolean)) |
| body = [ append('''«pkg.setIcon»''')] |
| ]) |
| // create menu |
| type.members += pkg.toMethod("getMenu", _typeReferenceBuilder.typeRef(VerticalLayout), [ |
| annotations += _annotationTypesBuilder.annotationRef(Override) |
| parameters += pkg.toParameter("popup", _typeReferenceBuilder.typeRef(PopupButton)) |
| body = [ append('''«pkg.getMenu»''')] |
| ]) |
| // locale notification |
| type.members += pkg.toMethod("localeChanged", _typeReferenceBuilder.typeRef(Void::TYPE), |
| [ |
| visibility = JvmVisibility.PUBLIC |
| annotations += _annotationTypesBuilder.annotationRef(Override) |
| parameters += pkg.toParameter("locale", _typeReferenceBuilder.typeRef(Locale)) |
| body = [append('''«pkg.localeChanged»''')] |
| ]) |
| // popupButton notification |
| type.members += pkg.toMethod("popupVisibilityChange", _typeReferenceBuilder.typeRef(Void::TYPE), |
| [ |
| visibility = JvmVisibility.PUBLIC |
| annotations += _annotationTypesBuilder.annotationRef(Override) |
| parameters += pkg.toParameter("event", _typeReferenceBuilder.typeRef(PopupVisibilityEvent)) |
| body = [append( |
| ''' |
| if(event.isPopupVisible()) { |
| registerEnablementUpdaters(); |
| } else { |
| unregisterEnablementUpdaters(); |
| }''')] |
| ]) |
| // registerEnablementUpdaters |
| type.members += pkg.toMethod("registerEnablementUpdaters", _typeReferenceBuilder.typeRef(Void::TYPE), |
| [ |
| visibility = JvmVisibility.PUBLIC |
| body = [append( |
| ''' |
| for(IMenuItemHandler handler:menuItems.keySet()) { |
| if (!enabledUpdaters.containsKey(menuItems.get(handler))) { |
| Runnable runnable = new Runnable() { |
| |
| @Override |
| public void run() { |
| boolean can = handler.canExecute(); |
| if(menuItems.get(handler).isEnabled() != can) { |
| menuItems.get(handler).setEnabled(can); |
| } |
| } |
| }; |
| this.enabledUpdaters.put(menuItems.get(handler), runnable); |
| executorService.invokeLaterAlways(runnable); |
| } |
| }''')] |
| ]) |
| // unregisterEnabalementUpdaters |
| type.members += pkg.toMethod("unregisterEnablementUpdaters", _typeReferenceBuilder.typeRef(Void::TYPE), |
| [ |
| visibility = JvmVisibility.PUBLIC |
| body = [append( |
| ''' |
| for(IMenuItemHandler handler:menuItems.keySet()) { |
| Runnable runnable = enabledUpdaters.remove(menuItems.get(handler)); |
| if (runnable != null) { |
| executorService.removeAlwaysRunnable(runnable); |
| } |
| }''')] |
| ]) |
| } |
| |
| def init(MenuPackage pkg) |
| ''' |
| bpmnWindow = new BpmnWindow(bpmEngine, blip, context); |
| tabs = new HashMap<>(); |
| items = new HashMap<>(); |
| user.addUserLocaleListener(this); |
| locale = user.getLocale(); |
| menuComponent = createMenu(); |
| localeChanged(locale);''' |
| |
| def getMenu(MenuPackage pkg) |
| ''' |
| popup.addPopupVisibilityListener(this); |
| return menuComponent; |
| ''' |
| |
| def createMenu(MenuPackage pkg) |
| ''' |
| selectedMap = new HashMap<Accordion,Component>(); |
| VerticalLayout tabRoot = new VerticalLayout(); |
| tabRoot.setSizeFull(); |
| «IF pkg.hasDesigner» |
| if (designModeHandler != null && userAccessService.isSuperuser()) { |
| MenuBar menubar = new MenuBar(); |
| tabRoot.addComponent(menubar); |
| MenuItem designer = menubar.addItem(designerText, null, null); |
| MenuItem mode = designer.addItem(designmodeText, null, new MenuBar.Command() { |
| public void menuSelected(MenuItem selectedItem) { |
| designModeHandler.execute(selectedItem); |
| } |
| }); |
| mode.setCheckable(true); |
| menuItems.put(designerUndoHandler, designer.addItem(undoText, null, new MenuBar.Command() { |
| public void menuSelected(MenuItem selectedItem) { |
| designerUndoHandler.execute(selectedItem); |
| } |
| })); |
| menuItems.put(designerRedoHandler, designer.addItem(redoText, null, new MenuBar.Command() { |
| public void menuSelected(MenuItem selectedItem) { |
| designerRedoHandler.execute(selectedItem); |
| } |
| })); |
| designer.addSeparator(); |
| menuItems.put(newPerspectiveHandler, designer.addItem(newText, null, new MenuBar.Command() { |
| public void menuSelected(MenuItem selectedItem) { |
| newPerspectiveHandler.execute(selectedItem); |
| } |
| })); |
| menuItems.put(changePerspectiveHandler, designer.addItem(changeText, null, new MenuBar.Command() { |
| public void menuSelected(MenuItem selectedItem) { |
| changePerspectiveHandler.execute(selectedItem); |
| } |
| })); |
| menuItems.put(exportPerspectiveHandler, designer.addItem(exportText, null, new MenuBar.Command() { |
| public void menuSelected(MenuItem selectedItem) { |
| exportPerspectiveHandler.execute(selectedItem); |
| } |
| })); |
| menuItems.put(downloadPerspectiveHandler, designer.addItem(downloadText, null, new MenuBar.Command() { |
| public void menuSelected(MenuItem selectedItem) { |
| downloadPerspectiveHandler.execute(selectedItem); |
| } |
| })); |
| } |
| «ENDIF» |
| «pkg.createRootMenu» |
| return tabRoot; |
| ''' |
| |
| def String createRootMenu(MenuPackage pkg) |
| ''' |
| ItemDescriptionGenerator generator = new ItemDescriptionGenerator() { |
| public String generateDescription(Component source, Object itemId, Object propertyId) { |
| return ((UserMenuItem)itemId).getI18nDescription(); |
| } |
| }; |
| MPerspective perspective = context.get(MPerspective.class); |
| ValueChangeListener valueChangeListener = new ValueChangeListener() { |
| @Override |
| public void valueChange(ValueChangeEvent event) { |
| UserMenuItem item = (UserMenuItem) ((Tree)event.getProperty()).getValue(); |
| if(item != null) { |
| if(item.getType() == UserMenuItemType.PROCESS) { |
| bpmnWindow.showBpmn(item.getCallId()); |
| } |
| else if(item.getType() == UserMenuItemType.PERSPECTIVE) { |
| bpmnWindow.closeBpmn(); |
| log.debug("start perspective "+item.getCallId()); |
| perspectiveProvider.openPerspective(item.getCallId()); |
| } |
| ((Tree)event.getProperty()).select(null); |
| } |
| EventDispatcherEvent evnt = new EventDispatcherEvent(perspective, EventDispatcherCommand.CLOSE, "UserMenu", "«pkg.fullyQualifiedName.toString»"); |
| eventDispatcher.sendEvent(evnt); |
| } |
| }; |
| Accordion accordion = new Accordion(); |
| tabRoot.addComponent(accordion); |
| «IF pkg.height !== null»accordion.setHeight("«pkg.height»");«ENDIF» |
| accordion.setWidth(«IF pkg.width !== null»"«pkg.width»"«ELSE»"400px"«ENDIF»); |
| accordion.addStyleName("os-accordion-level0"); |
| «selectedHandler("accordion")» |
| |
| «FOR category:pkg.categories» |
| «IF category.hasUserFilter» |
| if(userAccessService.isSuperuser()) { |
| «ELSE» |
| if(true) { |
| «ENDIF» |
| VerticalLayout tab«category.name.toFirstUpper» = new VerticalLayout(); |
| Tree category«category.name.toFirstUpper» = new Tree(); |
| if(dslMetadataService.isOsbee()) { |
| category«category.name.toFirstUpper».setDragMode(TreeDragMode.NODE); |
| } |
| category«category.name.toFirstUpper».addValueChangeListener(valueChangeListener); |
| category«category.name».setItemDescriptionGenerator(generator); |
| tab«category.name.toFirstUpper».addComponent(category«category.name.toFirstUpper»); |
| category«category.name.toFirstUpper».setWidth(«IF pkg.width !== null»"«pkg.width»"«ELSE»"400px"«ENDIF»); |
| category«category.name.toFirstUpper».addStyleName("os-menutree-level0"); |
| accordion.addTab(tab«category.name.toFirstUpper», "«category.name»", themeResourceService.getThemeResource("«pkg.collapsedImage»", ThemeResourceType.ICON)); |
| tabs.put(accordion.getTab(tab«category.name.toFirstUpper»), new Pair("«category.name»","")); |
| «IF category.hasTable» |
| «category.table.name.toFirstLower».createView(tab«category.name.toFirstUpper»); |
| tab«category.name.toFirstUpper».setData(«category.table.name.toFirstLower»); |
| «ELSEIF category.hasDialog» |
| «category.dialog.name.toFirstLower».createView(tab«category.name.toFirstUpper»); |
| tab«category.name.toFirstUpper».setData(«category.dialog.name.toFirstLower»); |
| «ELSEIF category.hasUserFilter» |
| userFilter.createView(tab«category.name.toFirstUpper»); |
| «ELSEIF category.hasKeyBinding» |
| keyBinding.createView(tab«category.name.toFirstUpper»); |
| «ELSEIF category.hasSystemSettings» |
| systemSettings.createView(tab«category.name.toFirstUpper»); |
| «ELSEIF category.hasReportPrinter» |
| reportPrinter.createView(tab«category.name.toFirstUpper»); |
| «ENDIF» |
| «FOR tree:category.trees» |
| UserMenuItem «tree.name» = new UserMenuItem(dslMetadataService, "«tree.name»", "«tree.name»", UserMenuItemType.NONE, "«tree.tooltip»", null); |
| items.put(«tree.name», "«tree.name»"); |
| category«category.name.toFirstUpper».addItem(«tree.name»); |
| category«category.name.toFirstUpper».setChildrenAllowed(«tree.name», true); |
| «FOR entry:tree.entries» |
| «IF entry.hasProcess» |
| if(bpmEngine != null && userAccessService.isGranted(Group.PROCESS, Action.STARTABLE, "«entry.process.name»")) { |
| «ELSE» |
| if(true) { |
| «ENDIF» |
| UserMenuItem «tree.name»«entry.name» = new UserMenuItem(dslMetadataService, "«entry.name»", |
| «IF entry.hasProcess»"«entry.process.name»" |
| «ELSEIF entry.hasPerspective»"«entry.perspective.fullyQualifiedName»" |
| «ELSE»"" |
| «ENDIF», UserMenuItemType.«IF entry.hasProcess»PROCESS, "«entry.process.descriptionValue»" |
| «ELSEIF entry.hasPerspective»PERSPECTIVE, "«entry.perspective.descriptionValue»"« |
| ELSE»NONE, "" |
| «ENDIF», "«entry.icon»"); |
| items.put(«tree.name»«entry.name», "«entry.name»"); |
| category«category.name.toFirstUpper».addItem(«tree.name»«entry.name»); |
| category«category.name.toFirstUpper».setParent(«tree.name»«entry.name», «tree.name»); |
| category«category.name.toFirstUpper».setChildrenAllowed(«tree.name»«entry.name», false); |
| «IF entry.hasIcon» |
| category«category.name.toFirstUpper».setItemIcon(«tree.name»«entry.name», themeResourceService.getThemeResource("«entry.icon»", ThemeResourceType.ICON)); |
| «ENDIF» |
| } |
| |
| «ENDFOR» |
| «ENDFOR» |
| } |
| «ENDFOR» |
| ''' |
| |
| def setIcon(MenuPackage pkg) { |
| ''' |
| Tab tab = accordion.getTab(selectedMap.get(accordion)); |
| if (tab != null) { |
| if(open) { |
| tab.setIcon(themeResourceService.getThemeResource("«pkg.expandedImage»", ThemeResourceType.ICON)); |
| } else { |
| tab.setIcon(themeResourceService.getThemeResource("«pkg.collapsedImage»", ThemeResourceType.ICON)); |
| } |
| } |
| ''' |
| } |
| |
| def selectedHandler(String accName) { |
| ''' |
| «accName».addSelectedTabChangeListener(new SelectedTabChangeListener() { |
| @Override |
| public void selectedTabChange(SelectedTabChangeEvent event) { |
| setIcon(«accName», false); |
| selectedMap.put(«accName», «accName».getSelectedTab()); |
| setIcon(«accName», true); |
| Component component = «accName».getSelectedTab(); |
| if(component instanceof AbstractOrderedLayout) { |
| if(((AbstractOrderedLayout)component).getData() instanceof IViewEmbeddedProvider) { |
| IViewEmbeddedProvider view = ((IViewEmbeddedProvider)((AbstractOrderedLayout)component).getData()); |
| view.createComponents(); |
| // eventDispatcher |
| EventDispatcherEvent evnt = new EventDispatcherEvent(perspective, EventDispatcherCommand.SELECT, userAccessService.getUser().getClass().getCanonicalName(), "Menu"); |
| evnt.addItem(EventDispatcherDataTag.DTO, userAccessService.getUser()); |
| eventDispatcher.sendEvent(evnt); |
| } |
| } |
| } |
| }); |
| ''' |
| } |
| |
| def localeChanged(MenuPackage pkg) |
| ''' |
| this.locale = locale; |
| for(TabSheet.Tab tab: tabs.keySet()) { |
| tab.setCaption(dslMetadataService.translate(locale.toLanguageTag(),tabs.get(tab).getKey())); |
| tab.setDescription(dslMetadataService.translate(locale.toLanguageTag(),tabs.get(tab).getValue())); |
| } |
| for(UserMenuItem item: items.keySet()) { |
| item.setLocale(locale); |
| } |
| designerText = dslMetadataService.translate(locale.toLanguageTag(),"designer"); |
| designmodeText = dslMetadataService.translate(locale.toLanguageTag(),"designermode"); |
| undoText = dslMetadataService.translate(locale.toLanguageTag(),"undo"); |
| redoText = dslMetadataService.translate(locale.toLanguageTag(),"redo"); |
| newText = dslMetadataService.translate(locale.toLanguageTag(),"new"); |
| changeText = dslMetadataService.translate(locale.toLanguageTag(),"change"); |
| exportText = dslMetadataService.translate(locale.toLanguageTag(),"export"); |
| downloadText = dslMetadataService.translate(locale.toLanguageTag(),"download"); |
| ''' |
| |
| def popupVisibilityChange(MenuPackage pkg) |
| ''' |
| if(event.isPopupVisible()) { |
| registerEnablementUpdaters(); |
| } else { |
| unregisterEnablementUpdaters(); |
| } |
| ''' |
| |
| } |