| /** |
| * |
| * 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 |
| * |
| */ |
| package org.eclipse.osbp.ecview.extension.presentation.tests.strategy; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotEquals; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertNotSame; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertSame; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.util.ArrayList; |
| import java.util.Dictionary; |
| import java.util.HashMap; |
| import java.util.Hashtable; |
| import java.util.Locale; |
| import java.util.Map; |
| |
| import org.eclipse.emf.ecore.util.EcoreUtil; |
| import org.eclipse.osbp.ecview.core.common.context.ContextException; |
| import org.eclipse.osbp.ecview.core.common.context.IViewContext; |
| import org.eclipse.osbp.ecview.core.common.editpart.DelegatingEditPartManager; |
| import org.eclipse.osbp.ecview.core.common.editpart.IEmbeddableEditpart; |
| import org.eclipse.osbp.ecview.core.common.editpart.binding.IBindingEditpart; |
| import org.eclipse.osbp.ecview.core.common.model.binding.BindingFactory; |
| import org.eclipse.osbp.ecview.core.common.model.binding.YBindingEndpoint; |
| import org.eclipse.osbp.ecview.core.common.model.binding.YListBinding; |
| import org.eclipse.osbp.ecview.core.common.model.binding.YListBindingEndpoint; |
| import org.eclipse.osbp.ecview.core.common.model.binding.YValueBinding; |
| import org.eclipse.osbp.ecview.core.common.model.binding.YValueBindingEndpoint; |
| import org.eclipse.osbp.ecview.core.common.model.core.CoreModelFactory; |
| import org.eclipse.osbp.ecview.core.common.model.core.YBeanSlot; |
| import org.eclipse.osbp.ecview.core.common.model.core.YCollectionBindable; |
| import org.eclipse.osbp.ecview.core.common.model.core.YElement; |
| import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable; |
| import org.eclipse.osbp.ecview.core.common.model.core.YEmbeddableCollectionEndpoint; |
| import org.eclipse.osbp.ecview.core.common.model.core.YFocusable; |
| import org.eclipse.osbp.ecview.core.common.model.core.YKeyCode; |
| import org.eclipse.osbp.ecview.core.common.model.core.YKeyStrokeDefinition; |
| import org.eclipse.osbp.ecview.core.common.model.core.YLayout; |
| import org.eclipse.osbp.ecview.core.common.model.core.YModifierKey; |
| import org.eclipse.osbp.ecview.core.common.model.core.YValueBindable; |
| import org.eclipse.osbp.ecview.core.common.model.core.YView; |
| import org.eclipse.osbp.ecview.core.common.services.IWidgetAssocationsService; |
| import org.eclipse.osbp.ecview.core.extension.model.extension.ExtensionModelFactory; |
| import org.eclipse.osbp.ecview.core.extension.model.extension.YDecimalField; |
| import org.eclipse.osbp.ecview.core.extension.model.extension.YTextField; |
| import org.eclipse.osbp.ecview.core.extension.model.extension.YVerticalLayout; |
| import org.eclipse.osbp.ecview.core.extension.model.extension.util.SimpleExtensionModelFactory; |
| import org.eclipse.osbp.ecview.core.ui.core.editparts.extension.IDecimalFieldEditpart; |
| import org.eclipse.osbp.ecview.core.ui.core.editparts.extension.ITextFieldEditpart; |
| import org.eclipse.osbp.ecview.core.ui.core.editparts.extension.IVerticalLayoutEditpart; |
| import org.eclipse.osbp.ecview.core.util.emf.ModelUtil; |
| import org.eclipse.osbp.ecview.extension.api.IFocusingStrategy; |
| import org.eclipse.osbp.ecview.extension.api.IFocusingStrategyProvider; |
| import org.eclipse.osbp.ecview.extension.api.ILayoutingStrategy; |
| import org.eclipse.osbp.ecview.extension.api.ILayoutingStrategyProvider; |
| import org.eclipse.osbp.ecview.extension.editparts.ILayoutingInfoEditpart; |
| import org.eclipse.osbp.ecview.extension.editparts.IStrategyLayoutEditpart; |
| import org.eclipse.osbp.ecview.extension.editparts.ISuspectLayoutingInfoEditpart; |
| import org.eclipse.osbp.ecview.extension.editparts.emf.StrategyLayoutEditpart; |
| import org.eclipse.osbp.ecview.extension.editparts.emf.strategies.DelegatingFocusingStrategyEditpart; |
| import org.eclipse.osbp.ecview.extension.editparts.emf.strategies.LayoutingStrategyEditpart; |
| import org.eclipse.osbp.ecview.extension.model.YDelegatingFocusingStrategy; |
| import org.eclipse.osbp.ecview.extension.model.YECviewFactory; |
| import org.eclipse.osbp.ecview.extension.model.YLayoutingInfo; |
| import org.eclipse.osbp.ecview.extension.model.YStrategyLayout; |
| import org.eclipse.osbp.ecview.extension.model.YSuspect; |
| import org.eclipse.osbp.ecview.extension.model.YSuspectInfo; |
| import org.eclipse.osbp.ecview.extension.presentation.vaadin.strategy.StrategyLayoutPresentation; |
| import org.eclipse.osbp.runtime.common.event.IEventBroker; |
| import org.eclipse.osbp.runtime.common.keystroke.KeyCode; |
| import org.eclipse.osbp.runtime.common.keystroke.KeyStrokeCallback; |
| import org.eclipse.osbp.runtime.common.keystroke.KeyStrokeDefinition; |
| import org.eclipse.osbp.runtime.common.keystroke.ModifierKey; |
| import org.eclipse.osbp.runtime.web.ecview.presentation.vaadin.VaadinRenderer; |
| import org.eclipse.osbp.runtime.web.vaadin.components.fields.DecimalField; |
| import org.eclipse.osbp.runtime.web.vaadin.databinding.VaadinObservables; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.knowhowlab.osgi.testing.utils.BundleUtils; |
| import org.knowhowlab.osgi.testing.utils.ServiceUtils; |
| import org.osgi.framework.BundleContext; |
| import org.osgi.framework.BundleException; |
| import org.osgi.framework.FrameworkUtil; |
| import org.osgi.service.cm.ConfigurationException; |
| |
| import com.vaadin.event.ActionManager; |
| import com.vaadin.event.ShortcutAction; |
| import com.vaadin.ui.AbstractComponent; |
| import com.vaadin.ui.Component; |
| import com.vaadin.ui.CssLayout; |
| import com.vaadin.ui.Panel; |
| import com.vaadin.ui.TextField; |
| import com.vaadin.ui.UI; |
| import com.vaadin.ui.VerticalLayout; |
| |
| import de.compex.ecview.extension.tests.dtos.Person; |
| |
| /** |
| * Tests the {@link StrategyLayoutPresentation}. |
| */ |
| public class StrategyLayoutTests { |
| |
| private SimpleExtensionModelFactory factory = new SimpleExtensionModelFactory(); |
| private YECviewFactory cxFactory = YECviewFactory.eINSTANCE; |
| private CssLayout rootLayout = new CssLayout(); |
| private IViewContext viewContext; |
| |
| @SuppressWarnings("unchecked") |
| private static <A> A findEditpart(YElement yElement) { |
| return (A) DelegatingEditPartManager.getInstance().findEditpart( |
| yElement); |
| } |
| |
| @SuppressWarnings("unchecked") |
| private <A> A getEditpart(YElement yElement) { |
| return (A) DelegatingEditPartManager.getInstance().getEditpart( |
| viewContext, yElement); |
| } |
| |
| /** |
| * Setup tests. |
| * |
| * @throws ConfigurationException |
| * @throws BundleException |
| */ |
| @Before |
| public void setup() throws ConfigurationException, BundleException { |
| BundleUtils.startBundleAsync(getBundleContext(), |
| "org.lunifera.runtime.event"); |
| |
| UI.setCurrent(new DefaultUI()); |
| UI.getCurrent().setContent(rootLayout); |
| VaadinObservables.activateRealm(UI.getCurrent()); |
| |
| Dictionary<String, Object> properties1 = new Hashtable<>(); |
| properties1.put("ecview.focusing.id", "default"); |
| getBundleContext().registerService(IFocusingStrategyProvider.class, new DefaultFocusingStrategyProvider(), properties1); |
| |
| Dictionary<String, Object> properties2 = new Hashtable<>(); |
| properties2.put("ecview.layouting.id", "Default"); |
| getBundleContext().registerService(ILayoutingStrategyProvider.class, new DefaultLayoutingStrategyProvider(), properties2); |
| |
| } |
| |
| private BundleContext getBundleContext() { |
| return FrameworkUtil.getBundle(getClass()).getBundleContext(); |
| } |
| |
| /** |
| * A very simple render without Suspects. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_SimpleRender() throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| viewContext = renderer.render(rootLayout, yView, null); |
| IStrategyLayoutEditpart layoutEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, yLayout); |
| StrategyLayoutPresentation layoutPres = layoutEP.getPresentation(); |
| |
| assertTrue(layoutPres.isRendered()); |
| assertFalse(layoutPres.isDisposed()); |
| assertTrue(layoutEP.isRendered()); |
| assertFalse(layoutEP.isDisposed()); |
| |
| layoutEP.requestDispose(); |
| assertFalse(layoutPres.isRendered()); |
| assertTrue(layoutPres.isDisposed()); |
| assertFalse(layoutEP.isRendered()); |
| assertTrue(layoutEP.isDisposed()); |
| } |
| |
| /** |
| * Tests for the default layouter. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_Layouter_Default() throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| // ---------------------------------------------------------- |
| // --------------------- Check bindings --------------------- |
| // ---------------------------------------------------------- |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(2, yView.getBindingSet().getTransientBindings().size()); |
| |
| IStrategyLayoutEditpart layoutEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, yLayout); |
| StrategyLayoutPresentation layoutPres = layoutEP.getPresentation(); |
| |
| // ---------------------------------------------------------- |
| // ------------- Read in the created editparts -------------- |
| // ---------------------------------------------------------- |
| YLayoutingInfo cxLayoutingInfo = yLayout.getLayoutingInfo(); |
| ILayoutingInfoEditpart cxLayoutingInfoEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, cxLayoutingInfo); |
| // ensure that strategy did some layouting |
| YEmbeddable yContent = cxLayoutingInfo.getContent(); |
| assertNotNull(yContent); |
| |
| // read the suspect layouting infos |
| // |
| YSuspectInfo nameSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos() |
| .get(0); |
| YSuspectInfo ageSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos() |
| .get(1); |
| ISuspectLayoutingInfoEditpart nameSuspectInfoEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, nameSuspectInfo); |
| ISuspectLayoutingInfoEditpart ageSuspectInfoEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, ageSuspectInfo); |
| |
| IVerticalLayoutEditpart contentEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, yContent); |
| |
| // do asserts |
| // |
| assertTrue(layoutPres.isRendered()); |
| assertFalse(layoutPres.isDisposed()); |
| |
| assertTrue(layoutEP.isRendered()); |
| assertFalse(layoutEP.isDisposed()); |
| assertTrue(contentEP.isRendered()); |
| assertFalse(contentEP.isDisposed()); |
| assertFalse(cxLayoutingInfoEP.isDisposed()); |
| assertFalse(nameSuspectInfoEP.isDisposed()); |
| assertFalse(ageSuspectInfoEP.isDisposed()); |
| |
| IEmbeddableEditpart child1 = contentEP.getElements().get(0); |
| IEmbeddableEditpart child2 = contentEP.getElements().get(1); |
| |
| // ensure, that layout elements have been created and rendered properly |
| assertTrue(child1 instanceof ITextFieldEditpart); |
| assertTrue(child2 instanceof IDecimalFieldEditpart); |
| assertTrue(child1.isRendered()); |
| assertFalse(child1.isDisposed()); |
| assertTrue(child2.isRendered()); |
| assertFalse(child2.isDisposed()); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Dispose the strategy ------------------- |
| // ---------------------------------------------------------- |
| layoutEP.requestDispose(); |
| |
| // do further tests |
| // |
| assertFalse(layoutPres.isRendered()); |
| assertTrue(layoutPres.isDisposed()); |
| |
| assertFalse(contentEP.isRendered()); |
| assertTrue(contentEP.isDisposed()); |
| assertFalse(layoutEP.isRendered()); |
| assertTrue(layoutEP.isDisposed()); |
| assertTrue(cxLayoutingInfoEP.isDisposed()); |
| assertTrue(nameSuspectInfoEP.isDisposed()); |
| assertTrue(ageSuspectInfoEP.isDisposed()); |
| |
| // ensure, that layout elements have been disposed properly |
| assertFalse(child1.isRendered()); |
| assertTrue(child1.isDisposed()); |
| assertFalse(child2.isRendered()); |
| assertTrue(child2.isDisposed()); |
| |
| // ensure, that editparts have been removed from models |
| assertNull(findEditpart(yLayout)); |
| assertNull(findEditpart(nameSuspect)); |
| assertNull(findEditpart(ageSuspect)); |
| assertNull(findEditpart(cxLayoutingInfo)); |
| assertNull(findEditpart(yContent)); |
| assertNull(findEditpart(nameSuspectInfo)); |
| assertNull(findEditpart(ageSuspectInfo)); |
| |
| // ensure bindings are removed |
| // |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(0, yView.getBindingSet().getTransientBindings().size()); |
| |
| } |
| |
| /** |
| * If a new default layout strategy provider is set and published by event |
| * admin, then the layout will update immediately. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_Layouter_DefaultByEventBroker() throws ContextException { |
| |
| IEventBroker eventBroker = ServiceUtils.getService(getBundleContext(), |
| IEventBroker.class); |
| assertNotNull(eventBroker); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| // ensure bindings are activated |
| // |
| assertEquals(2, yView.getBindingSet().getTransientBindings().size()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Read in the created editparts -------------- |
| // ---------------------------------------------------------- |
| IStrategyLayoutEditpart layoutEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, yLayout); |
| StrategyLayoutPresentation layoutPres = layoutEP.getPresentation(); |
| |
| // read the created layouting info |
| // |
| YLayoutingInfo cxLayoutingInfo = yLayout.getLayoutingInfo(); |
| ILayoutingInfoEditpart cxLayoutingInfoEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, cxLayoutingInfo); |
| // ensure that strategy did some layouting |
| YEmbeddable yContent = cxLayoutingInfo.getContent(); |
| assertNotNull(yContent); |
| |
| // read the suspect layouting infos |
| // |
| YSuspectInfo nameSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos() |
| .get(0); |
| YSuspectInfo ageSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos() |
| .get(1); |
| ISuspectLayoutingInfoEditpart nameSuspectInfoEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, nameSuspectInfo); |
| ISuspectLayoutingInfoEditpart ageSuspectInfoEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, ageSuspectInfo); |
| |
| IVerticalLayoutEditpart contentEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, yContent); |
| |
| // do asserts |
| // |
| assertTrue(layoutPres.isRendered()); |
| assertFalse(layoutPres.isDisposed()); |
| |
| assertTrue(layoutEP.isRendered()); |
| assertFalse(layoutEP.isDisposed()); |
| assertTrue(contentEP.isRendered()); |
| assertFalse(contentEP.isDisposed()); |
| assertFalse(cxLayoutingInfoEP.isDisposed()); |
| assertFalse(nameSuspectInfoEP.isDisposed()); |
| assertFalse(ageSuspectInfoEP.isDisposed()); |
| |
| IEmbeddableEditpart child1 = contentEP.getElements().get(0); |
| IEmbeddableEditpart child2 = contentEP.getElements().get(1); |
| |
| // ensure, that layout elements have been created and rendered properly |
| assertTrue(child1 instanceof ITextFieldEditpart); |
| assertTrue(child2 instanceof IDecimalFieldEditpart); |
| assertTrue(child1.isRendered()); |
| assertFalse(child1.isDisposed()); |
| assertTrue(child2.isRendered()); |
| assertFalse(child2.isDisposed()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Apply a new default strategy --------------- |
| // ---------------------------------------------------------- |
| OnlyLayoutTaggedStrategyProvider strategyProvider = new OnlyLayoutTaggedStrategyProvider(); |
| viewContext.registerService(ILayoutingStrategyProvider.class.getName(), |
| strategyProvider); |
| |
| eventBroker.send(ILayoutingStrategyProvider.ACTIVE_PROVIDER_TOPIC, |
| strategyProvider); |
| |
| StrategyLayoutEditpart implLayoutEP = (StrategyLayoutEditpart) layoutEP; |
| LayoutingStrategyEditpart<?> implStrategyEP = (LayoutingStrategyEditpart<?>) implLayoutEP |
| .getLayoutingStrategy(); |
| assertTrue(implStrategyEP.getStrategy() instanceof OnlyLayoutTaggedStrategy); |
| |
| // do asserts OLD values |
| // |
| assertFalse(layoutPres.isDisposed()); |
| assertFalse(layoutEP.isDisposed()); |
| assertTrue(contentEP.isDisposed()); |
| assertTrue(cxLayoutingInfoEP.isDisposed()); |
| assertTrue(nameSuspectInfoEP.isDisposed()); |
| assertTrue(ageSuspectInfoEP.isDisposed()); |
| assertFalse(child1.isRendered()); |
| assertTrue(child1.isDisposed()); |
| assertFalse(child2.isRendered()); |
| assertTrue(child2.isDisposed()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Read in the created editparts -------------- |
| // ---------------------------------------------------------- |
| cxLayoutingInfo = yLayout.getLayoutingInfo(); |
| cxLayoutingInfoEP = DelegatingEditPartManager.getInstance() |
| .getEditpart(viewContext, cxLayoutingInfo); |
| // ensure that strategy did some layouting |
| yContent = cxLayoutingInfo.getContent(); |
| assertNotNull(yContent); |
| |
| // read the suspect layouting infos |
| // |
| ageSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos().get(0); |
| ageSuspectInfoEP = DelegatingEditPartManager.getInstance().getEditpart( |
| viewContext, ageSuspectInfo); |
| |
| contentEP = DelegatingEditPartManager.getInstance().getEditpart( |
| viewContext, yContent); |
| |
| // do asserts |
| // |
| assertTrue(layoutPres.isRendered()); |
| assertFalse(layoutPres.isDisposed()); |
| |
| assertTrue(layoutEP.isRendered()); |
| assertFalse(layoutEP.isDisposed()); |
| assertTrue(contentEP.isRendered()); |
| assertFalse(contentEP.isDisposed()); |
| assertFalse(cxLayoutingInfoEP.isDisposed()); |
| assertFalse(ageSuspectInfoEP.isDisposed()); |
| |
| child1 = contentEP.getElements().get(0); |
| |
| // ensure, that layout elements have been created and rendered properly |
| assertTrue(child1 instanceof IDecimalFieldEditpart); |
| assertTrue(child1.isRendered()); |
| assertFalse(child1.isDisposed()); |
| |
| } |
| |
| /** |
| * Tests that YLayoutingInfo can become activated and deactivated. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_LayoutInfo_ActivateAndDeactivate() throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| // ensure bindings are activated |
| // |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(2, yView.getBindingSet().getTransientBindings().size()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Read in the created editparts -------------- |
| // ---------------------------------------------------------- |
| YLayoutingInfo cxLayoutingInfo = yLayout.getLayoutingInfo(); |
| ILayoutingInfoEditpart cxLayoutingInfoEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, cxLayoutingInfo); |
| YEmbeddable yContent = cxLayoutingInfo.getContent(); |
| assertNotNull(yContent); |
| |
| // read the suspect layouting infos |
| // |
| YSuspectInfo nameSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos() |
| .get(0); |
| YSuspectInfo ageSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos() |
| .get(1); |
| ISuspectLayoutingInfoEditpart nameSuspectInfoEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, nameSuspectInfo); |
| ISuspectLayoutingInfoEditpart ageSuspectInfoEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, ageSuspectInfo); |
| |
| // do asserts |
| // |
| assertFalse(cxLayoutingInfoEP.isDisposed()); |
| assertFalse(nameSuspectInfoEP.isDisposed()); |
| assertFalse(ageSuspectInfoEP.isDisposed()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Dispose the layouting info ----------------- |
| // ---------------------------------------------------------- |
| cxLayoutingInfoEP.requestDispose(); |
| |
| // do further tests |
| // |
| assertTrue(cxLayoutingInfoEP.isDisposed()); |
| assertTrue(nameSuspectInfoEP.isDisposed()); |
| assertTrue(ageSuspectInfoEP.isDisposed()); |
| |
| // ensure bindings are removed |
| // |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(0, yView.getBindingSet().getTransientBindings().size()); |
| |
| // ---------------------------------------------------------- |
| // ---------- Activate the layouting info again ------------- |
| // ---------------------------------------------------------- |
| yLayout.setLayoutingInfo(cxLayoutingInfo); |
| |
| // ---------------------------------------------------------- |
| // ------------- Read in the created editparts -------------- |
| // ---------------------------------------------------------- |
| cxLayoutingInfoEP = DelegatingEditPartManager.getInstance() |
| .getEditpart(viewContext, cxLayoutingInfo); |
| yContent = cxLayoutingInfo.getContent(); |
| assertNotNull(yContent); |
| |
| // read the suspect layouting infos |
| // |
| nameSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos().get(0); |
| ageSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos().get(1); |
| nameSuspectInfoEP = DelegatingEditPartManager.getInstance() |
| .getEditpart(viewContext, nameSuspectInfo); |
| ageSuspectInfoEP = DelegatingEditPartManager.getInstance().getEditpart( |
| viewContext, ageSuspectInfo); |
| |
| assertFalse(cxLayoutingInfoEP.isDisposed()); |
| assertFalse(nameSuspectInfoEP.isDisposed()); |
| assertFalse(ageSuspectInfoEP.isDisposed()); |
| |
| // ensure bindings are added again |
| // |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(2, yView.getBindingSet().getTransientBindings().size()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Dispose the layouting info ----------------- |
| // ---------------------------------------------------------- |
| cxLayoutingInfoEP.requestDispose(); |
| assertTrue(cxLayoutingInfoEP.isDisposed()); |
| assertTrue(nameSuspectInfoEP.isDisposed()); |
| assertTrue(ageSuspectInfoEP.isDisposed()); |
| |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(0, yView.getBindingSet().getTransientBindings().size()); |
| } |
| |
| /** |
| * Tests that bindings are setup properly. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_LayoutInfo_Bindings() throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| // ensure bindings are activated |
| // |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(2, yView.getBindingSet().getTransientBindings().size()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Read in the created editparts -------------- |
| // ---------------------------------------------------------- |
| YLayoutingInfo cxLayoutingInfo = yLayout.getLayoutingInfo(); |
| ILayoutingInfoEditpart cxLayoutingInfoEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, cxLayoutingInfo); |
| YVerticalLayout yContent = (YVerticalLayout) cxLayoutingInfo |
| .getContent(); |
| assertNotNull(yContent); |
| |
| // read the suspect layouting infos |
| // |
| YSuspectInfo nameSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos() |
| .get(0); |
| YSuspectInfo ageSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos() |
| .get(1); |
| ISuspectLayoutingInfoEditpart nameSuspectInfoEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, nameSuspectInfo); |
| ISuspectLayoutingInfoEditpart ageSuspectInfoEP = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, ageSuspectInfo); |
| |
| // do asserts |
| // |
| assertFalse(cxLayoutingInfoEP.isDisposed()); |
| assertFalse(nameSuspectInfoEP.isDisposed()); |
| assertFalse(ageSuspectInfoEP.isDisposed()); |
| |
| YTextField yNameField = (YTextField) yContent.getElement(0); |
| YDecimalField yAgeField = (YDecimalField) yContent.getElement(1); |
| TextField nameField = (TextField) ((IEmbeddableEditpart) findEditpart(yNameField)) |
| .getWidget(); |
| DecimalField ageField = (DecimalField) ((IEmbeddableEditpart) findEditpart(yAgeField)) |
| .getWidget(); |
| |
| Person bean = (Person) viewContext.getBean("main"); |
| bean.setName("My Name"); |
| bean.setAge(44); |
| assertEquals(bean.getName(), nameField.getValue()); |
| assertEquals(new Double(bean.getAge()), ageField.getConvertedValue()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Dispose the layouting info ----------------- |
| // ---------------------------------------------------------- |
| cxLayoutingInfoEP.requestDispose(); |
| |
| // do further tests |
| // |
| assertTrue(cxLayoutingInfoEP.isDisposed()); |
| assertTrue(nameSuspectInfoEP.isDisposed()); |
| assertTrue(ageSuspectInfoEP.isDisposed()); |
| |
| // ensure bindings are removed |
| // |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(0, yView.getBindingSet().getTransientBindings().size()); |
| |
| bean.setName("Other Name"); |
| bean.setAge(36); |
| assertNotEquals(bean.getName(), nameField.getValue()); |
| assertNotEquals(new Double(bean.getAge()), ageField.getConvertedValue()); |
| |
| // ---------------------------------------------------------- |
| // ---------- Activate the layouting info again ------------- |
| // ---------------------------------------------------------- |
| yLayout.setLayoutingInfo(cxLayoutingInfo); |
| |
| // ---------------------------------------------------------- |
| // ------------- Read in the created editparts -------------- |
| // ---------------------------------------------------------- |
| cxLayoutingInfoEP = DelegatingEditPartManager.getInstance() |
| .getEditpart(viewContext, cxLayoutingInfo); |
| yContent = (YVerticalLayout) cxLayoutingInfo.getContent(); |
| assertNotNull(yContent); |
| |
| // read the suspect layouting infos |
| // |
| nameSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos().get(0); |
| ageSuspectInfo = cxLayoutingInfo.getActiveSuspectInfos().get(1); |
| nameSuspectInfoEP = DelegatingEditPartManager.getInstance() |
| .getEditpart(viewContext, nameSuspectInfo); |
| ageSuspectInfoEP = DelegatingEditPartManager.getInstance().getEditpart( |
| viewContext, ageSuspectInfo); |
| |
| // get new Vaadin fields |
| yNameField = (YTextField) yContent.getElement(0); |
| yAgeField = (YDecimalField) yContent.getElement(1); |
| nameField = (TextField) ((IEmbeddableEditpart) findEditpart(yNameField)) |
| .getWidget(); |
| ageField = (DecimalField) ((IEmbeddableEditpart) findEditpart(yAgeField)) |
| .getWidget(); |
| |
| bean = (Person) viewContext.getBean("main"); |
| bean.setName("Just a test"); |
| bean.setAge(22); |
| assertEquals(bean.getName(), nameField.getValue()); |
| assertEquals(new Double(bean.getAge()), ageField.getConvertedValue()); |
| |
| assertFalse(cxLayoutingInfoEP.isDisposed()); |
| assertFalse(nameSuspectInfoEP.isDisposed()); |
| assertFalse(ageSuspectInfoEP.isDisposed()); |
| |
| // ensure bindings are added again |
| // |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(2, yView.getBindingSet().getTransientBindings().size()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Dispose the layouting info ----------------- |
| // ---------------------------------------------------------- |
| cxLayoutingInfoEP.requestDispose(); |
| assertTrue(cxLayoutingInfoEP.isDisposed()); |
| assertTrue(nameSuspectInfoEP.isDisposed()); |
| assertTrue(ageSuspectInfoEP.isDisposed()); |
| |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(0, yView.getBindingSet().getTransientBindings().size()); |
| |
| bean.setName("Another test"); |
| bean.setAge(44); |
| assertNotEquals(bean.getName(), nameField.getValue()); |
| assertNotEquals(new Double(bean.getAge()), ageField.getConvertedValue()); |
| } |
| |
| /** |
| * Switching the layoutInfo between two instances. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_LayoutInfo_SwitchInfo() throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| // ensure bindings are activated |
| // |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(2, yView.getBindingSet().getTransientBindings().size()); |
| |
| // read the created layouting info |
| // |
| YLayoutingInfo cxLayoutingInfo1 = yLayout.getLayoutingInfo(); |
| ILayoutingInfoEditpart cxLayoutingInfoEP1 = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, cxLayoutingInfo1); |
| YVerticalLayout yContent1 = (YVerticalLayout) cxLayoutingInfo1 |
| .getContent(); |
| assertNotNull(yContent1); |
| assertEquals(2, yContent1.getElements().size()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Read in the created editparts -------------- |
| // ---------------------------------------------------------- |
| YSuspectInfo nameSuspectInfo1_1 = cxLayoutingInfo1 |
| .getActiveSuspectInfos().get(0); |
| YSuspectInfo ageSuspectInfo1_2 = cxLayoutingInfo1 |
| .getActiveSuspectInfos().get(1); |
| ISuspectLayoutingInfoEditpart nameSuspectInfoEP1_1 = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, nameSuspectInfo1_1); |
| ISuspectLayoutingInfoEditpart ageSuspectInfoEP1_2 = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, ageSuspectInfo1_2); |
| |
| // ---------------------------------------------------------- |
| // ---------- Set a new layouting info manually ------------- |
| // ---------------------------------------------------------- |
| YLayoutingInfo cxLayoutingInfo2 = EcoreUtil.copy(cxLayoutingInfo1); |
| |
| // remove one field from the info |
| cxLayoutingInfo2.getActiveSuspectInfos().remove(0); |
| YVerticalLayout yContent2 = (YVerticalLayout) cxLayoutingInfo2 |
| .getContent(); |
| yContent2.getElements().remove(0); |
| |
| ILayoutingInfoEditpart cxLayoutingInfoEP2 = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, cxLayoutingInfo2); |
| |
| // read the suspect layouting infos |
| YSuspectInfo ageSuspectInfo2_1 = cxLayoutingInfo2 |
| .getActiveSuspectInfos().get(0); |
| ISuspectLayoutingInfoEditpart ageSuspectInfoEP2_1 = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, ageSuspectInfo2_1); |
| |
| // do asserts |
| // |
| assertFalse(cxLayoutingInfoEP1.isDisposed()); |
| assertFalse(nameSuspectInfoEP1_1.isDisposed()); |
| assertFalse(ageSuspectInfoEP1_2.isDisposed()); |
| |
| assertFalse(cxLayoutingInfoEP2.isDisposed()); |
| assertFalse(ageSuspectInfoEP2_1.isDisposed()); |
| |
| // currently 2 views active |
| YVerticalLayout yCurrentContent = (YVerticalLayout) yLayout |
| .getLayoutingInfo().getContent(); |
| assertEquals(2, yCurrentContent.getElements().size()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Now switch the layouting info -------------- |
| // ---------------------------------------------------------- |
| yLayout.setLayoutingInfo(cxLayoutingInfo2); |
| assertNotNull(yContent2); |
| assertEquals(1, yContent2.getElements().size()); |
| |
| assertTrue(cxLayoutingInfoEP1.isDisposed()); |
| assertTrue(nameSuspectInfoEP1_1.isDisposed()); |
| assertTrue(ageSuspectInfoEP1_2.isDisposed()); |
| |
| assertFalse(cxLayoutingInfoEP2.isDisposed()); |
| assertFalse(ageSuspectInfoEP2_1.isDisposed()); |
| |
| // ensure bindings are removed |
| // |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(1, yView.getBindingSet().getTransientBindings().size()); |
| |
| // currently 1 views active |
| yCurrentContent = (YVerticalLayout) yLayout.getLayoutingInfo() |
| .getContent(); |
| assertEquals(1, yCurrentContent.getElements().size()); |
| |
| // ---------------------------------------------------------- |
| // ------------------ And switch it back -------------------- |
| // ---------------------------------------------------------- |
| yLayout.setLayoutingInfo(cxLayoutingInfo1); |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(2, yView.getBindingSet().getTransientBindings().size()); |
| |
| cxLayoutingInfoEP1 = DelegatingEditPartManager.getInstance() |
| .getEditpart(viewContext, cxLayoutingInfo1); |
| yContent1 = (YVerticalLayout) cxLayoutingInfo1.getContent(); |
| assertNotNull(yContent1); |
| assertEquals(2, yContent1.getElements().size()); |
| |
| // read the suspect layouting infos again. NEW INSTANCES! |
| // |
| nameSuspectInfo1_1 = cxLayoutingInfo1.getActiveSuspectInfos().get(0); |
| ageSuspectInfo1_2 = cxLayoutingInfo1.getActiveSuspectInfos().get(1); |
| nameSuspectInfoEP1_1 = DelegatingEditPartManager.getInstance() |
| .getEditpart(viewContext, nameSuspectInfo1_1); |
| ageSuspectInfoEP1_2 = DelegatingEditPartManager.getInstance() |
| .getEditpart(viewContext, ageSuspectInfo1_2); |
| |
| assertFalse(cxLayoutingInfoEP1.isDisposed()); |
| assertFalse(nameSuspectInfoEP1_1.isDisposed()); |
| assertFalse(ageSuspectInfoEP1_2.isDisposed()); |
| |
| assertTrue(cxLayoutingInfoEP2.isDisposed()); |
| assertTrue(ageSuspectInfoEP2_1.isDisposed()); |
| |
| // ensure bindings are added again |
| // |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(2, yView.getBindingSet().getTransientBindings().size()); |
| |
| // currently 2 views active |
| yCurrentContent = (YVerticalLayout) yLayout.getLayoutingInfo() |
| .getContent(); |
| assertEquals(2, yCurrentContent.getElements().size()); |
| |
| // ---------------------------------------------------------- |
| // --------------- Dispose the layouting info --------------- |
| // ---------------------------------------------------------- |
| cxLayoutingInfoEP1.dispose(); |
| assertTrue(cxLayoutingInfoEP1.isDisposed()); |
| assertTrue(nameSuspectInfoEP1_1.isDisposed()); |
| assertTrue(ageSuspectInfoEP1_2.isDisposed()); |
| |
| assertEquals(0, yView.getBindingSet().getBindings().size()); |
| assertEquals(0, yView.getBindingSet().getTransientBindings().size()); |
| } |
| |
| /** |
| * Test to show, that active rendered YLayoutingInfo can be changed. The |
| * changes are reflected to the UI, but no complete relayouting is done. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_LayoutingInfo_ChangeValueInActive() |
| throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Read in the created editparts -------------- |
| // ---------------------------------------------------------- |
| YLayoutingInfo cxLayoutingInfo1 = yLayout.getLayoutingInfo(); |
| ILayoutingInfoEditpart cxLayoutingInfoEP1 = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, cxLayoutingInfo1); |
| YVerticalLayout yContent = (YVerticalLayout) cxLayoutingInfo1 |
| .getContent(); |
| assertNotNull(yContent); |
| assertEquals(2, yContent.getElements().size()); |
| |
| // read the suspect layouting infos |
| // |
| YSuspectInfo nameSuspectInfo1_1 = cxLayoutingInfo1 |
| .getActiveSuspectInfos().get(0); |
| YSuspectInfo ageSuspectInfo1_2 = cxLayoutingInfo1 |
| .getActiveSuspectInfos().get(1); |
| ISuspectLayoutingInfoEditpart nameSuspectInfoEP1_1 = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, nameSuspectInfo1_1); |
| ISuspectLayoutingInfoEditpart ageSuspectInfoEP1_2 = DelegatingEditPartManager |
| .getInstance().getEditpart(viewContext, ageSuspectInfo1_2); |
| |
| // ensure values |
| // |
| assertFalse(nameSuspectInfoEP1_1.isDisposed()); |
| assertFalse(ageSuspectInfoEP1_2.isDisposed()); |
| assertEquals(2, yView.getBindingSet().getTransientBindings().size()); |
| |
| // test Vaadin |
| VerticalLayout vl = (VerticalLayout) cxLayoutingInfoEP1.getContent() |
| .getWidget(); |
| assertEquals(2, vl.getComponentCount()); |
| |
| // ---------------------------------------------------------- |
| // -------------- Remove nameSuspectInfoEP1_1 --------------- |
| // ---------------------------------------------------------- |
| // now remove nameSuspectInfoEP1_1 and its representation |
| cxLayoutingInfo1.getActiveSuspectInfos().remove(0); |
| yContent = (YVerticalLayout) cxLayoutingInfo1.getContent(); |
| yContent.getElements().remove(0); |
| |
| // ---------------------------------------------------------- |
| // --------------- Ensure Vaadin updated UI ----------------- |
| // ------ No relayouting happend yet. Ui followed model------ |
| // ---------------------------------------------------------- |
| assertTrue(nameSuspectInfoEP1_1.isDisposed()); |
| assertFalse(cxLayoutingInfoEP1.isDisposed()); |
| assertFalse(ageSuspectInfoEP1_2.isDisposed()); |
| |
| // test Vaadin |
| vl = (VerticalLayout) cxLayoutingInfoEP1.getContent().getWidget(); |
| assertEquals(1, vl.getComponentCount()); |
| |
| // name was removed, so age needs to be index 0 |
| YSuspectInfo ageSuspectInfo2_1 = cxLayoutingInfo1 |
| .getActiveSuspectInfos().get(0); |
| assertFalse(ageSuspectInfoEP1_2.isDisposed()); |
| // ageSuspectInfoEP1_2 was NOT disposed |
| assertSame(ageSuspectInfoEP1_2, findEditpart(ageSuspectInfo2_1)); |
| assertEquals(1, yView.getBindingSet().getTransientBindings().size()); |
| |
| // Ui was updated |
| yContent = (YVerticalLayout) cxLayoutingInfo1.getContent(); |
| assertNotNull(yContent); |
| assertEquals(1, yContent.getElements().size()); |
| |
| vl = (VerticalLayout) cxLayoutingInfoEP1.getContent().getWidget(); |
| assertEquals(1, vl.getComponentCount()); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Do full relayouting -------------------- |
| // ---------------------------------------------------------- |
| IStrategyLayoutEditpart layoutEP = findEditpart(yLayout); |
| layoutEP.requestLayouting(); |
| |
| // all active editparts have been disposed |
| assertTrue(cxLayoutingInfoEP1.isDisposed()); |
| assertTrue(nameSuspectInfoEP1_1.isDisposed()); |
| assertTrue(ageSuspectInfoEP1_2.isDisposed()); |
| |
| cxLayoutingInfo1 = yLayout.getLayoutingInfo(); |
| cxLayoutingInfoEP1 = DelegatingEditPartManager.getInstance() |
| .getEditpart(viewContext, cxLayoutingInfo1); |
| yContent = (YVerticalLayout) cxLayoutingInfo1.getContent(); |
| assertNotNull(yContent); |
| assertEquals(2, yContent.getElements().size()); |
| |
| // read the suspect layouting infos |
| // |
| nameSuspectInfo1_1 = cxLayoutingInfo1.getActiveSuspectInfos().get(0); |
| ageSuspectInfo1_2 = cxLayoutingInfo1.getActiveSuspectInfos().get(1); |
| nameSuspectInfoEP1_1 = DelegatingEditPartManager.getInstance() |
| .getEditpart(viewContext, nameSuspectInfo1_1); |
| ageSuspectInfoEP1_2 = DelegatingEditPartManager.getInstance() |
| .getEditpart(viewContext, ageSuspectInfo1_2); |
| assertFalse(cxLayoutingInfoEP1.isDisposed()); |
| assertFalse(nameSuspectInfoEP1_1.isDisposed()); |
| assertFalse(ageSuspectInfoEP1_2.isDisposed()); |
| assertEquals(2, yView.getBindingSet().getTransientBindings().size()); |
| |
| // test Vaadin |
| vl = (VerticalLayout) cxLayoutingInfoEP1.getContent().getWidget(); |
| assertEquals(2, vl.getComponentCount()); |
| |
| viewContext.dispose(); |
| |
| } |
| |
| /** |
| * Test to show, that active rendered YLayoutingInfo can be changed. The |
| * changes are reflected to the UI, but no complete relayouting is done. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_LayoutingInfo_AddAndRemoveBindingValueInActive() |
| throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Read in the created editparts -------------- |
| // ---------------------------------------------------------- |
| YLayoutingInfo cxLayoutingInfo1 = yLayout.getLayoutingInfo(); |
| YVerticalLayout yContent = (YVerticalLayout) cxLayoutingInfo1 |
| .getContent(); |
| assertNotNull(yContent); |
| assertEquals(2, yContent.getElements().size()); |
| |
| // read the suspect layouting infos |
| // |
| YSuspectInfo nameSuspectInfo1_1 = cxLayoutingInfo1 |
| .getActiveSuspectInfos().get(0); |
| |
| // ---------------------------------------------------------- |
| // ----- Add a new binding to the active suspect info ------- |
| // ---------------------------------------------------------- |
| // make a copy -> otherwise the suspect will be changed |
| YValueBindingEndpoint yValueEPName = yBeanSlot |
| .createBindingEndpoint("name"); |
| YValueBindingEndpoint yValueEPName2 = yBeanSlot |
| .createBindingEndpoint("name2"); |
| YValueBinding yBinding = BindingFactory.eINSTANCE.createYValueBinding(); |
| yBinding.setModelEndpoint(yValueEPName); |
| yBinding.setTargetEndpoint(yValueEPName2); |
| nameSuspectInfo1_1.getBindings().add(yBinding); |
| |
| IBindingEditpart<?> bindingEP = findEditpart(yBinding); |
| |
| // ensure that binding is active |
| assertEquals(3, yView.getBindingSet().getTransientBindings().size()); |
| assertTrue(bindingEP.isBound()); |
| assertFalse(bindingEP.isDisposed()); |
| |
| // ---------------------------------------------------------- |
| // ---------------- Remove the binding again ---------------- |
| // ---------------------------------------------------------- |
| nameSuspectInfo1_1.getBindings().remove(yBinding); |
| assertEquals(2, yView.getBindingSet().getTransientBindings().size()); |
| assertTrue(bindingEP.isDisposed()); |
| assertFalse(bindingEP.isBound()); |
| |
| } |
| |
| /** |
| * Tests that adding a suspect directly by model has no bad effect. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_AddSuspect() throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Change the suspect --------------------- |
| // ---------------------------------------------------------- |
| YSuspect birthdaySuspect = cxFactory.createYSuspect(); |
| birthdaySuspect.setName("birthday"); |
| // ensure a decimal field |
| birthdaySuspect.getTags().add("date"); |
| birthdaySuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("birthday")); |
| yLayout.getSuspects().add(birthdaySuspect); |
| |
| // Ensure that new suspect did not change anything |
| YLayoutingInfo cxLayoutingInfo = yLayout.getLayoutingInfo(); |
| assertEquals(2, cxLayoutingInfo.getActiveSuspectInfos().size()); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Now do a relayout ---------------------- |
| // ----- And the new suspect should be added to the ui ----- |
| // ---------------------------------------------------------- |
| IStrategyLayoutEditpart layoutEP = findEditpart(yLayout); |
| layoutEP.requestLayouting(); |
| |
| cxLayoutingInfo = yLayout.getLayoutingInfo(); |
| assertEquals(3, cxLayoutingInfo.getActiveSuspectInfos().size()); |
| } |
| |
| /** |
| * Tests that adding a suspect directly by model has no bad effect. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_Layouter_RemoveSuspect() throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Remove the suspect -------------- |
| // ---------------------------------------------------------- |
| yLayout.getSuspects().remove(nameSuspect); |
| |
| // Ensure that new suspect did not change anything |
| YLayoutingInfo cxLayoutingInfo = yLayout.getLayoutingInfo(); |
| assertEquals(2, cxLayoutingInfo.getActiveSuspectInfos().size()); |
| |
| // ---------------------------------------------------------- |
| // ------------------ Do a relayouting ---------------------- |
| // ---------------------------------------------------------- |
| IStrategyLayoutEditpart layoutEP = findEditpart(yLayout); |
| layoutEP.requestLayouting(); |
| |
| cxLayoutingInfo = yLayout.getLayoutingInfo(); |
| assertEquals(1, cxLayoutingInfo.getActiveSuspectInfos().size()); |
| |
| } |
| |
| /** |
| * Tests for the default focusing. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_Focusing_Default() throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| // |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the focusing strategy --------------- |
| // ---------------------------------------------------------- |
| YDelegatingFocusingStrategy cxStrategy = cxFactory |
| .createYDelegatingFocusingStrategy(); |
| cxStrategy.setDelegateStrategyId("default"); |
| cxStrategy.setKeyStrokeDefinition(null); |
| yLayout.getFocusingStrategies().add(cxStrategy); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| StrategyLayoutEditpart layoutEP = findEditpart(yLayout); |
| |
| // ---------------------------------------------------------- |
| // ------------- Ensure proper keystroke def --------------- |
| // ---------------------------------------------------------- |
| DelegatingFocusingStrategyEditpart strategyEP = getEditpart(cxStrategy); |
| KeyStrokeDefinition keyStrokeDef = strategyEP.getKeyStrokeDefinition() |
| .getDefinition(); |
| assertEquals(KeyCode.TAB, keyStrokeDef.getKeyCode()); |
| assertEquals(0, keyStrokeDef.getModifierKeys().length); |
| |
| DefaultFocusingStrategy stgy = (DefaultFocusingStrategy) strategyEP |
| .getStrategy(); |
| assertEquals(0, stgy.calledCount); |
| assertEquals(1, layoutEP.getKeystrokeCallbacks().size()); |
| |
| // ---------------------------------------------------------- |
| // ------------- Ensure focusing is done -------------------- |
| // ---------------------------------------------------------- |
| KeyStrokeCallback callback = layoutEP.getKeystrokeCallbacks().get( |
| strategyEP); |
| callback.callback(null, null); |
| assertEquals(1, stgy.calledCount); |
| |
| // ---------------------------------------------------------- |
| // ------------- Ensure focus strategy removed -------------- |
| // ---------------------------------------------------------- |
| yLayout.getFocusingStrategies().clear(); |
| assertEquals(0, yLayout.getFocusingStrategies().size()); |
| assertTrue(strategyEP.isDisposed()); |
| assertEquals(0, layoutEP.getKeystrokeCallbacks().size()); |
| |
| try { |
| callback.callback(null, null); |
| fail("Exception is required"); |
| } catch (Exception e) { |
| } |
| |
| } |
| |
| /** |
| * Tests for the focusing with two focusing strategies. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_Focusing_WithTwoStrategies() throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| // |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create two focusing strategies --------------- |
| // ---------------------------------------------------------- |
| YDelegatingFocusingStrategy cxStrategy1 = cxFactory |
| .createYDelegatingFocusingStrategy(); |
| cxStrategy1.setDelegateStrategyId("default"); |
| cxStrategy1.setKeyStrokeDefinition(null); |
| yLayout.getFocusingStrategies().add(cxStrategy1); |
| |
| YDelegatingFocusingStrategy cxStrategy2 = cxFactory |
| .createYDelegatingFocusingStrategy(); |
| cxStrategy2.setDelegateStrategyId("default"); |
| cxStrategy2.setKeyStrokeDefinition(null); |
| yLayout.getFocusingStrategies().add(cxStrategy2); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| StrategyLayoutEditpart layoutEP = findEditpart(yLayout); |
| |
| // ---------------------------------------------------------- |
| // ------------- Ensure proper keystroke def --------------- |
| // ---------------------------------------------------------- |
| DelegatingFocusingStrategyEditpart strategy1EP = findEditpart(cxStrategy1); |
| KeyStrokeDefinition keyStrokeDef1 = strategy1EP |
| .getKeyStrokeDefinition().getDefinition(); |
| assertEquals(KeyCode.TAB, keyStrokeDef1.getKeyCode()); |
| assertEquals(0, keyStrokeDef1.getModifierKeys().length); |
| |
| DefaultFocusingStrategy stgy1 = (DefaultFocusingStrategy) strategy1EP |
| .getStrategy(); |
| assertEquals(0, stgy1.calledCount); |
| |
| DelegatingFocusingStrategyEditpart strategy2EP = findEditpart(cxStrategy2); |
| KeyStrokeDefinition keyStrokeDef2 = strategy2EP |
| .getKeyStrokeDefinition().getDefinition(); |
| assertEquals(KeyCode.TAB, keyStrokeDef2.getKeyCode()); |
| assertEquals(0, keyStrokeDef2.getModifierKeys().length); |
| |
| DefaultFocusingStrategy stgy2 = (DefaultFocusingStrategy) strategy2EP |
| .getStrategy(); |
| assertEquals(0, stgy2.calledCount); |
| |
| // ensure two callbacks available |
| assertEquals(2, layoutEP.getKeystrokeCallbacks().size()); |
| |
| assertNotSame(strategy1EP, strategy2EP); |
| assertNotSame(stgy1, stgy2); |
| |
| // ---------------------------------------------------------- |
| // ------------- Ensure focusing is done -------------------- |
| // ---------------------------------------------------------- |
| KeyStrokeCallback callback1 = layoutEP.getKeystrokeCallbacks().get( |
| strategy1EP); |
| callback1.callback(null, null); |
| assertEquals(1, stgy1.calledCount); |
| |
| KeyStrokeCallback callback2 = layoutEP.getKeystrokeCallbacks().get( |
| strategy2EP); |
| callback2.callback(null, null); |
| assertEquals(1, stgy2.calledCount); |
| |
| // ---------------------------------------------------------- |
| // ------------- Now remove strategy 1 ---------------------- |
| // ---------------------------------------------------------- |
| yLayout.getFocusingStrategies().remove(0); |
| |
| assertEquals(1, yLayout.getFocusingStrategies().size()); |
| assertTrue(strategy1EP.isDisposed()); |
| assertEquals(1, layoutEP.getKeystrokeCallbacks().size()); |
| |
| try { |
| callback1.callback(null, null); |
| fail("Exception is required"); |
| } catch (Exception e) { |
| } |
| |
| // ---------------------------------------------------------- |
| // ------------- Now add another strategy ------------------- |
| // ------------- with keystroke definitions ----------------- |
| // ---------------------------------------------------------- |
| |
| YDelegatingFocusingStrategy cxStrategy3 = cxFactory |
| .createYDelegatingFocusingStrategy(); |
| cxStrategy3.setDelegateStrategyId("default"); |
| YKeyStrokeDefinition yKeyStrokeDef3 = CoreModelFactory.eINSTANCE |
| .createYKeyStrokeDefinition(); |
| yKeyStrokeDef3.setKeyCode(YKeyCode.B); |
| yKeyStrokeDef3.getModifierKeys().add(YModifierKey.ALT); |
| yKeyStrokeDef3.getModifierKeys().add(YModifierKey.CTRL); |
| cxStrategy3.setKeyStrokeDefinition(yKeyStrokeDef3); |
| yLayout.getFocusingStrategies().add(cxStrategy3); |
| |
| DelegatingFocusingStrategyEditpart strategy3EP = findEditpart(cxStrategy3); |
| KeyStrokeDefinition keyStrokeDef3 = strategy3EP |
| .getKeyStrokeDefinition().getDefinition(); |
| assertEquals(KeyCode.B, keyStrokeDef3.getKeyCode()); |
| assertEquals(2, keyStrokeDef3.getModifierKeys().length); |
| |
| DefaultFocusingStrategy stgy3 = (DefaultFocusingStrategy) strategy3EP |
| .getStrategy(); |
| assertEquals(0, stgy3.calledCount); |
| |
| // ensure two callbacks available |
| assertEquals(2, layoutEP.getKeystrokeCallbacks().size()); |
| |
| KeyStrokeCallback callback3 = layoutEP.getKeystrokeCallbacks().get( |
| strategy3EP); |
| callback3.callback(null, null); |
| assertEquals(1, stgy3.calledCount); |
| |
| callback3.callback(null, null); |
| assertEquals(2, stgy3.calledCount); |
| |
| // ---------------------------------------------------------- |
| // ------------- Now dispose all focusing strategies -------- |
| // ---------------------------------------------------------- |
| yLayout.getFocusingStrategies().remove(0); |
| yLayout.getFocusingStrategies().remove(0); |
| |
| assertTrue(strategy2EP.isDisposed()); |
| assertTrue(strategy3EP.isDisposed()); |
| |
| assertEquals(0, yLayout.getFocusingStrategies().size()); |
| assertEquals(0, layoutEP.getKeystrokeCallbacks().size()); |
| try { |
| callback2.callback(null, null); |
| fail("Exception is required"); |
| } catch (Exception e) { |
| } |
| try { |
| callback3.callback(null, null); |
| fail("Exception is required"); |
| } catch (Exception e) { |
| } |
| } |
| |
| /** |
| * Tests for the event management in Vaadin. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_Focusing_VaadinEvents() throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| // |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the focusing strategy --------------- |
| // ---------------------------------------------------------- |
| YDelegatingFocusingStrategy cxStrategy = cxFactory |
| .createYDelegatingFocusingStrategy(); |
| cxStrategy.setDelegateStrategyId("default"); |
| cxStrategy.setKeyStrokeDefinition(null); |
| yLayout.getFocusingStrategies().add(cxStrategy); |
| |
| YKeyStrokeDefinition yKeyStrokeDef = CoreModelFactory.eINSTANCE |
| .createYKeyStrokeDefinition(); |
| yKeyStrokeDef.setKeyCode(YKeyCode.TAB); |
| yKeyStrokeDef.getModifierKeys().add(YModifierKey.ALT); |
| yKeyStrokeDef.getModifierKeys().add(YModifierKey.CTRL); |
| cxStrategy.setKeyStrokeDefinition(yKeyStrokeDef); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| StrategyLayoutEditpart layoutEP = findEditpart(yLayout); |
| |
| // ---------------------------------------------------------- |
| // ------------- Ensure proper keystroke def --------------- |
| // ---------------------------------------------------------- |
| DelegatingFocusingStrategyEditpart strategyEP = getEditpart(cxStrategy); |
| DefaultFocusingStrategy stgy = (DefaultFocusingStrategy) strategyEP |
| .getStrategy(); |
| assertEquals(0, stgy.calledCount); |
| |
| // ---------------------------------------------------------- |
| // ------------- Ensure focusing is done -------------------- |
| // ---------------------------------------------------------- |
| Panel panel = (Panel) layoutEP.getWidget(); |
| ActionManager actionManager = getActionManager(panel); |
| |
| ShortcutAction action = (ShortcutAction) actionManager.getActions(null, |
| null)[0]; |
| VerticalLayout panelContent = (VerticalLayout) panel.getContent(); |
| VerticalLayout innerPanelContent = (VerticalLayout) panelContent |
| .getComponent(0); |
| actionManager.handleAction(action, panel, |
| innerPanelContent.getComponent(0)); |
| assertEquals(1, stgy.calledCount); |
| |
| ShortcutAction action2 = new ShortcutAction("", KeyCode.ENTER, |
| new int[] { ModifierKey.SHIFT }); |
| actionManager.handleAction(action2, panel, panel); |
| assertEquals(1, stgy.calledCount); |
| } |
| |
| /** |
| * Tests for the event management in Vaadin. |
| * |
| * @throws ContextException |
| */ |
| @Test |
| public void test_Focusing_FieldGetsFocus() throws ContextException { |
| |
| // switch the global locale to german |
| Locale.setDefault(Locale.GERMAN); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the layout -------------------------- |
| // ---------------------------------------------------------- |
| YView yView = factory.createView(); |
| YBeanSlot yBeanSlot = yView.addBeanSlot("main", Person.class); |
| |
| YStrategyLayout yLayout = cxFactory.createYStrategyLayout(); |
| yView.setContent(yLayout); |
| |
| // create suspects |
| // |
| YSuspect nameSuspect = cxFactory.createYSuspect(); |
| nameSuspect.setName("name"); |
| nameSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("name")); |
| yLayout.getSuspects().add(nameSuspect); |
| YSuspect ageSuspect = cxFactory.createYSuspect(); |
| ageSuspect.setName("age"); |
| // ensure a decimal field |
| ageSuspect.getTags().add("decimal"); |
| ageSuspect.getValueBindingEndpoints().add( |
| yBeanSlot.createBindingEndpoint("age")); |
| yLayout.getSuspects().add(ageSuspect); |
| |
| // ---------------------------------------------------------- |
| // ------------- Create the focusing strategy --------------- |
| // ---------------------------------------------------------- |
| YDelegatingFocusingStrategy cxStrategy = cxFactory |
| .createYDelegatingFocusingStrategy(); |
| cxStrategy.setDelegateStrategyId("default"); |
| cxStrategy.setKeyStrokeDefinition(null); |
| yLayout.getFocusingStrategies().add(cxStrategy); |
| |
| YKeyStrokeDefinition yKeyStrokeDef = CoreModelFactory.eINSTANCE |
| .createYKeyStrokeDefinition(); |
| yKeyStrokeDef.setKeyCode(YKeyCode.TAB); |
| yKeyStrokeDef.getModifierKeys().add(YModifierKey.ALT); |
| yKeyStrokeDef.getModifierKeys().add(YModifierKey.CTRL); |
| cxStrategy.setKeyStrokeDefinition(yKeyStrokeDef); |
| |
| // ---------------------------------------------------------- |
| // ----------------- Render the UI -------------------------- |
| // ---------------------------------------------------------- |
| VaadinRenderer renderer = new VaadinRenderer(); |
| Map<String, Object> params = new HashMap<String, Object>(); |
| Map<String, Object> services = new HashMap<String, Object>(); |
| |
| params.put(IViewContext.PARAM_SERVICES, services); |
| services.put(ILayoutingStrategyProvider.class.getName(), |
| new DefaultLayoutingStrategyProvider()); |
| services.put(IFocusingStrategyProvider.class.getName(), |
| new DefaultFocusingStrategyProvider()); |
| |
| viewContext = renderer.render(rootLayout, yView, params); |
| viewContext.setBean("main", new Person()); |
| |
| StrategyLayoutEditpart layoutEP = findEditpart(yLayout); |
| DelegatingFocusingStrategyEditpart strategyEP = getEditpart(cxStrategy); |
| DefaultFocusingStrategy stgy = (DefaultFocusingStrategy) strategyEP |
| .getStrategy(); |
| assertEquals(0, stgy.calledCount); |
| |
| // ---------------------------------------------------------- |
| // ------------- Ensure focusing is done -------------------- |
| // ---------------------------------------------------------- |
| Panel panel = (Panel) layoutEP.getWidget(); |
| ActionManager actionManager = getActionManager(panel); |
| |
| YVerticalLayout yContent = (YVerticalLayout) yLayout.getLayoutingInfo() |
| .getContent(); |
| YTextField yNameField = (YTextField) yContent.getElements().get(0); |
| YDecimalField yAgeField = (YDecimalField) yContent.getElements().get(1); |
| |
| // set the name field to be focused now |
| yView.setCurrentFocus(yNameField); |
| |
| // now send an TAB-event. Then the age fields needs to have the focus. |
| ShortcutAction action = (ShortcutAction) actionManager.getActions(null, |
| null)[0]; |
| VerticalLayout panelContent = (VerticalLayout) panel.getContent(); |
| VerticalLayout innerPanelContent = (VerticalLayout) panelContent |
| .getComponent(0); |
| actionManager.handleAction(action, panel, |
| innerPanelContent.getComponent(0)); |
| assertSame(yView.getCurrentFocus(), yAgeField); |
| |
| // send an event that is not handled |
| ShortcutAction action2 = new ShortcutAction("", KeyCode.ENTER, |
| new int[] { ModifierKey.SHIFT }); |
| actionManager.handleAction(action2, panel, panel); |
| assertSame(yView.getCurrentFocus(), yAgeField); |
| |
| // now send another proper event |
| actionManager.handleAction(action, panel, |
| innerPanelContent.getComponent(1)); |
| assertSame(yView.getCurrentFocus(), yNameField); |
| |
| } |
| |
| protected ActionManager getActionManager(Component panel) { |
| ActionManager actionManager = null; |
| try { |
| Method m = AbstractComponent.class.getDeclaredMethod( |
| "getActionManager", new Class[0]); |
| if (!m.isAccessible()) { |
| m.setAccessible(true); |
| } |
| actionManager = (ActionManager) m.invoke(panel, new Object[0]); |
| } catch (NoSuchMethodException | IllegalAccessException |
| | InvocationTargetException e) { |
| fail(e.toString()); |
| } |
| return actionManager; |
| } |
| |
| private static class DefaultLayoutingStrategyProvider implements |
| ILayoutingStrategyProvider { |
| |
| @Override |
| public ILayoutingStrategy getStrategy() { |
| return new DefaultLayoutingStrategy(); |
| } |
| |
| } |
| |
| private static class OnlyLayoutTaggedStrategyProvider implements |
| ILayoutingStrategyProvider { |
| |
| @Override |
| public ILayoutingStrategy getStrategy() { |
| return new OnlyLayoutTaggedStrategy(); |
| } |
| |
| } |
| |
| public static class DefaultFocusingStrategyProvider implements |
| IFocusingStrategyProvider { |
| |
| private IFocusingStrategy strategy; |
| |
| @Override |
| public IFocusingStrategy getStrategy() { |
| return strategy != null ? strategy : new DefaultFocusingStrategy(); |
| } |
| } |
| |
| protected static class DefaultLayoutingStrategy implements |
| ILayoutingStrategy { |
| |
| @Override |
| public void layout(YLayoutingInfo layoutingInfo) { |
| YStrategyLayout cxLayout = layoutingInfo.getLayout(); |
| layoutingInfo.getActiveSuspectInfos().clear(); |
| |
| YVerticalLayout content = ExtensionModelFactory.eINSTANCE |
| .createYVerticalLayout(); |
| |
| for (YSuspect suspect : new ArrayList<YSuspect>( |
| cxLayout.getSuspects())) { |
| YSuspectInfo suspectInfo = layoutingInfo |
| .createSuspectInfo(suspect); |
| // add the suspectInfo as active suspect |
| layoutingInfo.getActiveSuspectInfos().add(suspectInfo); |
| |
| YEmbeddable yEmbeddable = prepareElementForSuspect(suspectInfo); |
| content.addElement(yEmbeddable); |
| } |
| |
| layoutingInfo.setContent(content); |
| } |
| |
| /** |
| * Creates a new element for the given suspect. Handle bindings,... |
| * |
| * @param suspectInfo |
| * @return |
| */ |
| protected YEmbeddable prepareElementForSuspect(YSuspectInfo suspectInfo) { |
| // create a new element for the given suspect |
| YEmbeddable yEmbeddable = createElementForSuspect(suspectInfo); |
| |
| // prepares the value bindings |
| prepareValueBindings(suspectInfo, yEmbeddable); |
| |
| return yEmbeddable; |
| } |
| |
| protected void prepareValueBindings(YSuspectInfo suspectInfo, |
| YEmbeddable yEmbeddable) { |
| YSuspect cxSuspect = suspectInfo.getSuspect(); |
| // iterate over all elements |
| for (YBindingEndpoint ep : cxSuspect.getValueBindingEndpoints()) { |
| |
| /* |
| * if yEmbeddable is a value bindable and ep a value binding |
| */ |
| if (ep instanceof YValueBindingEndpoint |
| && yEmbeddable instanceof YValueBindable) { |
| YValueBindable yBindable = (YValueBindable) yEmbeddable; |
| // make a copy -> otherwise the suspect will be changed |
| YBindingEndpoint epCopy = EcoreUtil.copy(ep); |
| |
| YValueBindingEndpoint yValueEP = yBindable |
| .createValueEndpoint(); |
| YValueBinding yBinding = BindingFactory.eINSTANCE |
| .createYValueBinding(); |
| yBinding.setModelEndpoint((YValueBindingEndpoint) epCopy); |
| yBinding.setTargetEndpoint(yValueEP); |
| |
| // register binding add suspect. Will be handled |
| // automatically. |
| suspectInfo.getBindings().add(yBinding); |
| |
| /* |
| * if yEmbeddable is a collection bindable and ep a list |
| * binding |
| */ |
| } else if (ep instanceof YListBindingEndpoint |
| && yEmbeddable instanceof YCollectionBindable) { |
| YCollectionBindable yBindable = (YCollectionBindable) yEmbeddable; |
| // make a copy -> otherwise the suspect will be changed |
| YBindingEndpoint epCopy = EcoreUtil.copy(ep); |
| |
| YEmbeddableCollectionEndpoint yListEP = yBindable |
| .createCollectionEndpoint(); |
| YListBinding yBinding = BindingFactory.eINSTANCE |
| .createYListBinding(); |
| yBinding.setModelEndpoint((YListBindingEndpoint) epCopy); |
| yBinding.setTargetEndpoint(yListEP); |
| |
| // register binding add suspect. Will be handled |
| // automatically. |
| suspectInfo.getBindings().add(yBinding); |
| } |
| } |
| } |
| |
| protected YEmbeddable createElementForSuspect(YSuspectInfo suspectInfo) { |
| YSuspect cxSuspect = suspectInfo.getSuspect(); |
| YEmbeddable yEmbeddable = null; |
| if (cxSuspect.getTags().contains("decimal")) { |
| yEmbeddable = ExtensionModelFactory.eINSTANCE |
| .createYDecimalField(); |
| } else { |
| yEmbeddable = ExtensionModelFactory.eINSTANCE |
| .createYTextField(); |
| } |
| return yEmbeddable; |
| } |
| } |
| |
| protected static class OnlyLayoutTaggedStrategy extends |
| DefaultLayoutingStrategy { |
| |
| @Override |
| public void layout(YLayoutingInfo layoutingInfo) { |
| YStrategyLayout cxLayout = layoutingInfo.getLayout(); |
| layoutingInfo.getActiveSuspectInfos().clear(); |
| |
| YVerticalLayout content = ExtensionModelFactory.eINSTANCE |
| .createYVerticalLayout(); |
| |
| for (YSuspect suspect : new ArrayList<YSuspect>( |
| cxLayout.getSuspects())) { |
| if (suspect.getTags().isEmpty()) { |
| continue; |
| } |
| YSuspectInfo suspectInfo = layoutingInfo |
| .createSuspectInfo(suspect); |
| // add the suspectInfo as active suspect |
| layoutingInfo.getActiveSuspectInfos().add(suspectInfo); |
| |
| YEmbeddable yEmbeddable = prepareElementForSuspect(suspectInfo); |
| content.addElement(yEmbeddable); |
| } |
| |
| layoutingInfo.setContent(content); |
| } |
| } |
| |
| /** |
| * The default focusing strategy focuses the next field in the order they |
| * appear in the layout. |
| */ |
| private static class DefaultFocusingStrategy implements IFocusingStrategy { |
| |
| protected int calledCount; |
| |
| @Override |
| public void focus(Object source, Object target, YStrategyLayout cxLayout) { |
| calledCount++; |
| |
| YView yView = cxLayout.getView(); |
| IViewContext context = ModelUtil.getViewContext(yView); |
| IWidgetAssocationsService<Object, ? extends YElement> service = context |
| .getService(IWidgetAssocationsService.ID); |
| YEmbeddable yCurrentFocus = (YEmbeddable) service |
| .getModelElement(target); |
| YEmbeddable yNextFocus = findNextElementToFocus(yCurrentFocus); |
| |
| yView.setCurrentFocus((YFocusable) yNextFocus); |
| |
| } |
| |
| /** |
| * Looks for the next element to be focused. Therefore it uses a round |
| * robin approach. If end of elements are reached, we start by index = 0 |
| * again. |
| * |
| * @param yElement |
| * @return |
| */ |
| protected YEmbeddable findNextElementToFocus(YEmbeddable yElement) { |
| if (yElement == null) { |
| return null; |
| } |
| YLayout yParent = (YLayout) yElement.eContainer(); |
| int index = yParent.getElements().indexOf(yElement); |
| if (index == yParent.getElements().size() - 1) { |
| // element is the last -> Start again |
| index = 0; |
| } else { |
| // use the next element |
| index = index + 1; |
| } |
| |
| YEmbeddable nextFocusElement = yParent.getElements().get(index); |
| return nextFocusElement; |
| } |
| |
| @Override |
| public KeyStrokeDefinition getKeyStrokeDefinition() { |
| // returns the default keystroke definition if nothing else was |
| // defined. |
| KeyStrokeDefinition result = new KeyStrokeDefinition("TestMe", |
| KeyCode.TAB, new int[0]); |
| return result; |
| } |
| |
| } |
| |
| private static class OtherFocusingStrategy extends DefaultFocusingStrategy { |
| |
| } |
| |
| } |