/**
 *                                                                            
 *  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();
		}
	'''
	
}