| /*************************************************************************************************** |
| * Copyright (c) 2003, 2005 IBM Corporation and others. All rights reserved. This program and the |
| * accompanying materials are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| |
| * |
| * Contributors: IBM Corporation - initial API and implementation |
| **************************************************************************************************/ |
| package org.eclipse.wst.common.tests.ui.manager; |
| |
| import java.util.HashSet; |
| import java.util.Set; |
| import java.util.Vector; |
| |
| import junit.framework.TestCase; |
| |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.wst.common.environment.EnvironmentService; |
| import org.eclipse.wst.common.frameworks.datamodel.AbstractDataModelProvider; |
| import org.eclipse.wst.common.frameworks.datamodel.DataModelFactory; |
| import org.eclipse.wst.common.frameworks.datamodel.IDataModel; |
| import org.eclipse.wst.common.frameworks.datamodel.IDataModelOperation; |
| import org.eclipse.wst.common.frameworks.internal.datamodel.DataModelImpl; |
| import org.eclipse.wst.common.frameworks.internal.datamodel.DataModelPausibleOperationImpl; |
| import org.eclipse.wst.common.frameworks.internal.datamodel.IDataModelPausibleOperation; |
| import org.eclipse.wst.common.frameworks.internal.datamodel.ui.DataModelWizardPage; |
| import org.eclipse.wst.common.frameworks.internal.datamodel.ui.IDMPageGroupHandler; |
| import org.eclipse.wst.common.frameworks.internal.datamodel.ui.IDMPageHandler; |
| import org.eclipse.wst.common.frameworks.internal.datamodel.ui.SimplePageGroup; |
| import org.eclipse.wst.common.frameworks.internal.ui.PageGroupManager; |
| |
| public class TestGroupManager extends TestCase { |
| |
| private IDataModelPausibleOperation rootOperation; |
| |
| private PageGroupManager pageGroupManager; |
| private SimplePageGroup pgA; |
| private SimplePageGroup pgB; |
| private SimplePageGroup pgC; |
| private SimplePageGroup pgD; |
| private SimplePageGroup pgE; |
| private SimplePageGroup pgF; |
| private SimplePageGroup pgG; |
| private SimplePageGroup pgH; |
| private SimplePageGroup pgRoot; |
| private WizardPage r1; |
| private WizardPage b1; |
| private WizardPage b2; |
| private WizardPage c1; |
| private WizardPage d1; |
| private WizardPage d2; |
| private WizardPage d3; |
| private WizardPage f1; |
| private WizardPage f2; |
| private WizardPage f3; |
| private WizardPage f4; |
| private WizardPage f5; |
| private WizardPage f6; |
| private WizardPage g1; |
| |
| private AGroupHandler aGroupHandler; |
| private FGroupHandler fGroupHandler; |
| private Vector expectedOps; |
| private Vector expectedUndoOps; |
| private IDataModel dataModel; |
| |
| public static final String a = A.class.getName(); |
| public static final String b = B.class.getName(); |
| public static final String c = C.class.getName(); |
| public static final String d = D.class.getName(); |
| public static final String e = E.class.getName(); |
| public static final String f = F.class.getName(); |
| public static final String g = G.class.getName(); |
| |
| |
| protected void setUp() throws Exception { |
| super.setUp(); |
| BaseOperation.resultList = new Vector(); |
| BaseOperation.undoList = new Vector(); |
| |
| expectedOps = new Vector(); |
| expectedUndoOps = new Vector(); |
| dataModel = new DataModelImpl(new EmptyProvider()); |
| dataModel.addNestedModel("testprovider1", DataModelFactory.createDataModel(new TestProvider1())); |
| dataModel.addNestedModel("testprovider2", DataModelFactory.createDataModel(new TestProvider2())); |
| dataModel.addNestedModel("testextendedprovider", DataModelFactory.createDataModel(new TestExtendedProvider())); |
| |
| /** |
| * Operations are organized as follows: <code> |
| * D |
| * / \ |
| * / \ |
| * B F |
| * / \ / \ |
| * A C E G |
| * </code> |
| */ |
| rootOperation = new DataModelPausibleOperationImpl(new D()); |
| rootOperation.setDataModel(dataModel); |
| rootOperation.setEnvironment(EnvironmentService.getEclipseConsoleEnvironment()); |
| |
| /** |
| * Page groups are organized as follows: |
| * |
| * <code> |
| * |
| * B - C |
| * / \ |
| * Root - A - D \ G |
| * \ \ / |
| * ------ E - F - H |
| * \ null |
| * </code> |
| */ |
| |
| // The page group handler for A will return either B and then E or D and |
| // then E. The group handler for F will return either G or H and then null or |
| // just null. |
| // |
| // Some of these group require operations to run first: |
| // |
| // Page group B requires operation C. |
| // Page group D requires operation C. |
| // Page group E requires operation E. |
| // Page group F requires operation C.( C will already have been run and should not be |
| // rerun.) |
| // |
| // Each page group has some pages associated with it as follows: |
| // |
| // Root has page r1. |
| // A has no pages. |
| // B has b1 and b2. |
| // C has c1 |
| // D has d1, d2, and d3 |
| // E has no pages. |
| // F has pages f1, f2, f3, f4, f5, f6 |
| // the page handler for F will return the following: |
| // expected = f1 returns f1 |
| // expected = f2 returns skip |
| // expected = f3 returns before f6 |
| // expected = f4 returns null |
| // expected = f5 returns after f5 |
| // expected = f6 returns f4 |
| // G has pages g1 |
| // H has no pages. |
| r1 = new WizardPage("r1"); //$NON-NLS-1$ |
| b1 = new WizardPage("b1"); //$NON-NLS-1$ |
| b2 = new WizardPage("b2"); //$NON-NLS-1$ |
| c1 = new WizardPage("c1"); //$NON-NLS-1$ |
| d1 = new WizardPage("d1"); //$NON-NLS-1$ |
| d2 = new WizardPage("d2"); //$NON-NLS-1$ |
| d3 = new WizardPage("d3"); //$NON-NLS-1$ |
| f1 = new WizardPage("f1"); //$NON-NLS-1$ |
| f2 = new WizardPage("f2"); //$NON-NLS-1$ |
| f3 = new WizardPage("f3"); //$NON-NLS-1$ |
| f4 = new WizardPage("f4"); //$NON-NLS-1$ |
| f5 = new WizardPage("f5"); //$NON-NLS-1$ |
| f6 = new WizardPage("f6"); //$NON-NLS-1$ |
| g1 = new WizardPage("g1"); //$NON-NLS-1$ |
| |
| String wizardID = "testWizard"; //$NON-NLS-1$ |
| |
| pgRoot = new SimplePageGroup("Root", wizardID); //$NON-NLS-1$ |
| pgA = new SimplePageGroup("A", wizardID); //$NON-NLS-1$ |
| pgB = new SimplePageGroup("B", wizardID, true, c); //$NON-NLS-1$ //$NON-NLS-2$ |
| pgC = new SimplePageGroup("C", wizardID); //$NON-NLS-1$ |
| pgD = new SimplePageGroup("D", wizardID, true, c); //$NON-NLS-1$ //$NON-NLS-2$ |
| pgE = new SimplePageGroup("E", wizardID, true, e); //$NON-NLS-1$ //$NON-NLS-2$ |
| pgF = new SimplePageGroup("F", wizardID, true, c); //$NON-NLS-1$ //$NON-NLS-2$ |
| pgG = new SimplePageGroup("G", wizardID); //$NON-NLS-1$ |
| pgH = new SimplePageGroup("H", wizardID); //$NON-NLS-1$ |
| |
| pgRoot.addPages(new WizardPage[]{r1}); |
| pgB.addPages(new WizardPage[]{b1, b2}); |
| pgC.addPages(new WizardPage[]{c1}); |
| pgD.addPages(new WizardPage[]{d1, d2, d3}); |
| pgF.addPages(new WizardPage[]{f1, f2, f3, f4, f5, f6}); |
| pgG.addPages(new WizardPage[]{g1}); |
| |
| pgF.setPageHandler(new FPageHandler()); |
| |
| aGroupHandler = new AGroupHandler(); |
| fGroupHandler = new FGroupHandler(); |
| |
| pgA.setPageGroupHandler(aGroupHandler); |
| pgF.setPageGroupHandler(fGroupHandler); |
| |
| pageGroupManager = new PageGroupManager(rootOperation, pgRoot); |
| pageGroupManager.addGroupAfter("Root", pgA); //$NON-NLS-1$ |
| pageGroupManager.addGroupAfter("A", pgB); //$NON-NLS-1$ |
| pageGroupManager.addGroupAfter("A", pgD); //$NON-NLS-1$ |
| pageGroupManager.addGroupAfter("A", pgE); //$NON-NLS-1$ |
| pageGroupManager.addGroupAfter("B", pgC); //$NON-NLS-1$ |
| pageGroupManager.addGroupAfter("E", pgF); //$NON-NLS-1$ |
| pageGroupManager.addGroupAfter("F", pgG); //$NON-NLS-1$ |
| pageGroupManager.addGroupAfter("F", pgH); //$NON-NLS-1$ |
| } |
| |
| public void testSimpleRun() throws Exception { |
| HashSet ids = new HashSet(); |
| ids.add("testprovider1"); |
| ids.add("testprovider2"); |
| pgA.setDataModelIDs(ids); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The root page should be null", pageGroupManager.getCurrentPage() == null); //$NON-NLS-1$ |
| pageGroupManager.moveBackOnePage(); // Should do nothing. |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| aGroupHandler.setGroupIDToSelect("B"); //$NON-NLS-1$ |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be r1", pageGroupManager.getCurrentPage() == r1); //$NON-NLS-1$ |
| checkResults(); |
| assertTrue("Data models not Ok for page group A", checkDataModels()); //$NON-NLS-1$ |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be b1", pageGroupManager.getCurrentPage() == b1); //$NON-NLS-1$ |
| expectedOps.add(a); |
| expectedOps.add(b); |
| expectedOps.add(c); |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be b2", pageGroupManager.getCurrentPage() == b2); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be c1", pageGroupManager.getCurrentPage() == c1); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f1", pageGroupManager.getCurrentPage() == f1); //$NON-NLS-1$ |
| expectedOps.add(d); |
| expectedOps.add(e); |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f3", pageGroupManager.getCurrentPage() == f3); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f5", pageGroupManager.getCurrentPage() == f5); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f6", pageGroupManager.getCurrentPage() == f6); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| fGroupHandler.setGroupIDToSelect("G"); //$NON-NLS-1$ |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f4", pageGroupManager.getCurrentPage() == f4); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertFalse("There should not be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be g1", pageGroupManager.getCurrentPage() == g1); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveBackOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f4", pageGroupManager.getCurrentPage() == f4); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveBackOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f4", pageGroupManager.getCurrentPage() == f6); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveBackOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f4", pageGroupManager.getCurrentPage() == f5); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveBackOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f4", pageGroupManager.getCurrentPage() == f3); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveBackOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f4", pageGroupManager.getCurrentPage() == f1); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveBackOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f4", pageGroupManager.getCurrentPage() == c1); //$NON-NLS-1$ |
| expectedOps.setSize(3); |
| expectedUndoOps.add(e); |
| expectedUndoOps.add(d); |
| checkResults(); |
| |
| pageGroupManager.moveBackOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be b2", pageGroupManager.getCurrentPage() == b2); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveBackOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be b1", pageGroupManager.getCurrentPage() == b1); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveBackOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The root page should be r1", pageGroupManager.getCurrentPage() == r1); //$NON-NLS-1$ |
| expectedOps = new Vector(); |
| expectedUndoOps.add(c); |
| expectedUndoOps.add(b); |
| expectedUndoOps.add(a); |
| checkResults(); |
| |
| reset(); |
| aGroupHandler.setGroupIDToSelect("D"); //$NON-NLS-1$ |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be d1", pageGroupManager.getCurrentPage() == d1); //$NON-NLS-1$ |
| expectedOps.add(a); |
| expectedOps.add(b); |
| expectedOps.add(c); |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be d2", pageGroupManager.getCurrentPage() == d2); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be d3", pageGroupManager.getCurrentPage() == d3); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f1", pageGroupManager.getCurrentPage() == f1); //$NON-NLS-1$ |
| expectedOps.add(d); |
| expectedOps.add(e); |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f3", pageGroupManager.getCurrentPage() == f3); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f5", pageGroupManager.getCurrentPage() == f5); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| assertTrue("There should be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f6", pageGroupManager.getCurrentPage() == f6); //$NON-NLS-1$ |
| checkResults(); |
| |
| pageGroupManager.moveForwardOnePage(); |
| fGroupHandler.setGroupIDToSelect(null); |
| assertFalse("There should not be a next page", pageGroupManager.hasNextPage()); //$NON-NLS-1$ |
| assertTrue("The page should be f4", pageGroupManager.getCurrentPage() == f4); //$NON-NLS-1$ |
| checkResults(); |
| } |
| |
| private void checkResults() { |
| assertTrue("Expected=" + expectedOps.size() + " executed=" + BaseOperation.resultList.size(), BaseOperation.resultList.size() == expectedOps.size()); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| for (int index = 0; index < BaseOperation.resultList.size(); index++) { |
| assertEquals(expectedOps.elementAt(index), BaseOperation.resultList.elementAt(index)); |
| } |
| |
| assertTrue("Expected undo=" + expectedUndoOps.size() + " executed=" + BaseOperation.undoList.size(), BaseOperation.undoList.size() == expectedUndoOps.size()); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| for (int index = 0; index < BaseOperation.undoList.size(); index++) { |
| assertEquals(expectedUndoOps.elementAt(index), BaseOperation.undoList.elementAt(index)); |
| } |
| } |
| |
| private void reset() { |
| BaseOperation.resultList.removeAllElements(); |
| expectedOps.removeAllElements(); |
| BaseOperation.undoList.removeAllElements(); |
| expectedUndoOps.removeAllElements(); |
| } |
| |
| private boolean checkDataModels() { |
| IDataModel model = dataModel; |
| |
| boolean containsModel1 = model.isNestedModel("testprovider1"); |
| boolean containsModel2 = model.isNestedModel("testprovider2"); |
| boolean prop1 = model.isPropertySet("provider1Prop1"); |
| boolean prop2 = model.isPropertySet("provider1Prop2"); |
| boolean prop3 = model.isPropertySet("provider1Prop3"); |
| boolean prop4 = model.isPropertySet("provider1Prop4"); |
| boolean prop5 = model.isPropertySet("provider2Prop1"); |
| boolean prop6 = model.isPropertySet("provider2Prop2"); |
| boolean prop7 = model.isPropertySet("provider2Prop3"); |
| boolean prop8 = model.isPropertySet("provider2Prop4"); |
| boolean value1 = model.getProperty("provider1Prop1").equals("11"); |
| boolean value2 = model.getProperty("provider1Prop2").equals("22"); |
| boolean value3 = model.getProperty("provider1Prop3").equals("33"); |
| boolean value4 = model.getProperty("provider1Prop4").equals("44"); |
| boolean value5 = model.getProperty("provider2Prop1").equals("1111"); |
| boolean value6 = model.getProperty("provider2Prop2").equals("2222"); |
| boolean value7 = model.getProperty("provider2Prop3").equals("3333"); |
| boolean value8 = model.getProperty("provider2Prop4").equals("4444"); |
| |
| return containsModel1 && containsModel2 && prop1 && prop2 && prop3 && prop4 && prop5 && prop6 && prop7 && prop8 && value1 && value2 && value3 && value4 && value5 && value6 && value7 && value8; |
| } |
| |
| private class AGroupHandler implements IDMPageGroupHandler { |
| private String groupID_; |
| |
| public String getNextPageGroup(String currentPageGroupID, String[] pageGroupIDs) { |
| String result = null; |
| |
| if (currentPageGroupID == null) { |
| result = groupID_; |
| } else if (currentPageGroupID.equals("E")) { //$NON-NLS-1$ |
| result = null; |
| } else { |
| result = "E"; //$NON-NLS-1$ |
| } |
| |
| return result; |
| } |
| |
| public void setGroupIDToSelect(String id) { |
| groupID_ = id; |
| } |
| } |
| |
| private class FGroupHandler implements IDMPageGroupHandler { |
| private String groupID_; |
| |
| public String getNextPageGroup(String currentPageGroupID, String[] pageGroupIDs) { |
| if (currentPageGroupID == null) |
| return groupID_; |
| |
| return null; |
| } |
| |
| public void setGroupIDToSelect(String id) { |
| groupID_ = id; |
| } |
| } |
| |
| // |
| // F has pages f1, f2, f3, f4, f5, f6 |
| // the page handler for F will return the following: |
| // expected = f1 returns f1 |
| // expected = f2 returns skip |
| // expected = f3 returns before f6 |
| // expected = f4 returns null |
| // expected = f5 returns after f5 |
| // expected = f6 returns f4 |
| // |
| // This handle should cause the following pages to be used. |
| // f1, f3, f5, f6, f4, null |
| // |
| private class FPageHandler implements IDMPageHandler { |
| public String getNextPage(String currentPageName, String expectedNextPageName) { |
| String result = null; |
| |
| if (currentPageName == null) { |
| result = "f1"; //$NON-NLS-1$ |
| } else if (currentPageName.equals("f1")) { //$NON-NLS-1$ |
| result = IDMPageHandler.SKIP_PAGE; |
| } else if (currentPageName.equals("f3")) { //$NON-NLS-1$ |
| result = IDMPageHandler.PAGE_BEFORE + "f6"; //$NON-NLS-1$ |
| } else if (currentPageName.equals("f4")) { //$NON-NLS-1$ |
| result = null; |
| } else if (currentPageName.equals("f5")) { //$NON-NLS-1$ |
| result = IDMPageHandler.PAGE_AFTER + "f5"; //$NON-NLS-1$ |
| } else if (currentPageName.equals("f6")) { //$NON-NLS-1$ |
| result = "f4"; //$NON-NLS-1$ |
| } |
| |
| return result; |
| } |
| |
| public String getPreviousPage(String currentPageName, String expectedPreviousPageName) { |
| return expectedPreviousPageName; |
| } |
| |
| } |
| |
| private class EmptyProvider extends AbstractDataModelProvider { |
| |
| public Set getPropertyNames() { |
| return new HashSet(); |
| } |
| } |
| |
| private class WizardPage extends DataModelWizardPage { |
| private boolean canFinish_ = true; |
| |
| public WizardPage(String id) { |
| super(dataModel, id); |
| } |
| |
| protected Composite createTopLevelComposite(Composite parent) { |
| return null; |
| } |
| |
| protected String[] getValidationPropertyNames() { |
| return new String[0]; |
| } |
| |
| public void setCanFinish(boolean canFinish) { |
| canFinish_ = canFinish; |
| } |
| |
| public boolean canPageFinish() { |
| return canFinish_; |
| } |
| |
| public IDataModelOperation createOperation() { |
| return null; |
| } |
| } |
| } |
