public code v1

bundles/flintstones.method.dEvaluation.phase.aggregation.ui/.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

bundles/flintstones.method.dEvaluation.phase.aggregation.ui/.project

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>flintstones.method.dEvaluation.phase.aggregation.ui</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

bundles/flintstones.method.dEvaluation.phase.aggregation.ui/.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding/<project>=UTF-8

bundles/flintstones.method.dEvaluation.phase.aggregation.ui/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,9 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=11
+org.eclipse.jdt.core.compiler.compliance=11
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
+org.eclipse.jdt.core.compiler.release=enabled
+org.eclipse.jdt.core.compiler.source=11

bundles/flintstones.method.dEvaluation.phase.aggregation.ui/META-INF/MANIFEST.MF

@@ -0,0 +1,19 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: dEvaluation method aggregation phase ui
+Bundle-SymbolicName: flintstones.method.dEvaluation.phase.aggregation.ui;singleton:=true
+Bundle-Version: 1.0.0.qualifier
+Bundle-Vendor: Sinbad2
+Automatic-Module-Name: flintstones.method.dEvaluation.phase.aggregation.ui
+Bundle-RequiredExecutionEnvironment: JavaSE-11
+Require-Bundle: flintstones.entity.method.phase.ui,
+ flintstones.model.ui.service,
+ flintstones.method.dEvaluation.phase.aggregation,
+ flintstones.entity.method.phase,
+ flintstones.helper.ui,
+ flintstones.helper.data,
+ flintstones.helper.html,
+ flintstones.entity.problemelement.ui,
+ org.eclipse.swt,
+ flintstones.entity.operator,
+ flintstones.valuation.fuzzy

bundles/flintstones.method.dEvaluation.phase.aggregation.ui/build.properties

@@ -0,0 +1,5 @@
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .,\
+               plugin.xml

bundles/flintstones.method.dEvaluation.phase.aggregation.ui/plugin.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<plugin>
+   <extension
+         point="flintstones.phasemethod.ui">
+      <phasemethod_ui
+            implementation="flintstones.method.dEvaluation.phase.aggregation.ui.AggregationUI"
+            phasemethod="flintstones.method.dEvaluation.phase.aggregation"
+            uid="flintstones.method.dEvaluation.phase.aggregation.ui">
+      </phasemethod_ui>
+   </extension>
+
+</plugin>

bundles/flintstones.method.dEvaluation.phase.aggregation.ui/src/flintstones/method/dEvaluation/phase/aggregation/ui/AggregationUI.java

@@ -0,0 +1,512 @@
+package flintstones.method.dEvaluation.phase.aggregation.ui;
+
+
+import flintstones.entity.method.phase.ui.PhaseMethodUI;
+import flintstones.entity.operator.AggregationOperator;
+import flintstones.entity.operator.interfaces.IParameterizedOperator;
+import flintstones.entity.problemelement.entities.Criterion;
+import flintstones.entity.problemelement.entities.Expert;
+import flintstones.entity.problemelement.entities.ProblemElement;
+import flintstones.entity.problemelement.ui.widget.ProblemElementSelector;
+import flintstones.entity.problemelement.ui.widget.listener.IProblemElementChangedListener;
+import flintstones.helper.DoubleHelper;
+import flintstones.helper.html.table.HtmlTextTable;
+import flintstones.helper.ui.components.WCollector;
+import flintstones.helper.ui.components.listeners.WEvent;
+import flintstones.helper.ui.components.listeners.WItemBeforeOperation;
+import flintstones.helper.ui.components.listeners.WItemChanged;
+import flintstones.helper.ui.components.listeners.WItemOperation;
+import flintstones.method.dEvaluation.phase.aggregation.DEvaluationAggregationModel;
+import flintstones.model.ui.service.UiService;
+import flintstones.valuation.fuzzy.FuzzyValuation;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+
+import org.eclipse.jface.resource.JFaceResources;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Combo;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+
+public class AggregationUI extends PhaseMethodUI  {
+	
+	private DEvaluationAggregationModel model;
+	
+	private Combo operatorsCombo;
+	
+	private WCollector criteriaCollector;
+	private WCollector subcriteriaCollector;
+	
+	private HtmlTextTable decisionMatrixExpert;
+	private HtmlTextTable decisionMatrix;
+	
+	private ProblemElementSelector expertSelector;
+	private ProblemElementSelector criterionSelector;
+	
+	@Override
+	public void init() {
+		model = (DEvaluationAggregationModel) this.getModel();
+		model.init();
+		
+		Composite base = this.getBaseComposite();
+		UiService.setGridData(base, 9, 9, true, true);
+		UiService.setGridLayout(base, 1);
+		
+		Composite twoColumns = new Composite(base, SWT.NONE);
+		UiService.setGridData(twoColumns, 9, 9, true, true);
+		UiService.setGridLayout(twoColumns, 2);
+		
+		createExpertDataPart(twoColumns);
+	}
+
+	private void createExpertDataPart(Composite twoColumns) {
+		createLeftPart(twoColumns);
+		createRightPart(twoColumns);
+	}
+
+	private void createLeftPart(Composite twoColumns) {
+		Composite leftPart = new Composite(twoColumns, SWT.BORDER);
+		UiService.setGridData(leftPart, 9, 9, true, true);
+		UiService.setGridLayout(leftPart, 1);
+		
+		Label expertWeights = new Label(leftPart, SWT.BOLD);
+		UiService.setGridData(expertWeights, -1, -1, false, false);
+		expertWeights.setText("Expert's weights");
+		expertWeights.setFont(JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT));
+		
+		Composite expertsSelectorComposite = new Composite(leftPart, SWT.BORDER);
+		UiService.setGridLayout(expertsSelectorComposite, 3, false);
+		UiService.setGridData(expertsSelectorComposite, 0, -1, true, false);
+		
+		expertSelector = new ProblemElementSelector(expertsSelectorComposite, model.getExperts());
+		expertSelector.setText(Expert.Type);
+		expertSelector.setListener(new IProblemElementChangedListener() {
+			@Override
+			public void problemElementChanged(ProblemElement pe) {
+			
+				HashMap<String, Double> criteriaWeights = model.getCriteriaParentWeights(expertSelector.getSelectedElement().getName());
+				
+				String[] items = model.getCriteriaParentName();
+
+				ArrayList<String> data = new ArrayList<>();
+
+				for (String criterion: items) {
+					Double value = criteriaWeights.get(criterion);
+					if (value != null)
+						data.add(value + ""); //$NON-NLS-1$
+				}
+
+				criteriaCollector.setValues(data);
+				
+				updateOperator();
+				updateSubcriteriaCollectorData(criterionSelector.getSelectedElement());
+				
+				refresh();
+			}
+		});
+		
+		Button load = new Button(expertsSelectorComposite, SWT.NONE);
+		UiService.setGridData(load, 0, -1, true, false);
+		load.setText("Load data");
+		load.addSelectionListener(new SelectionAdapter() {
+			@Override
+			public void widgetSelected(SelectionEvent e) {
+				model.loadData();
+			}
+		});
+		
+		createCriterionCollectorWeight(leftPart);
+		createSubcriterionCollectorWeight(leftPart);
+		createExpertDecisionMatrix(leftPart);
+	}
+
+	private void checkAllCriteriaWeights() {
+		String[] criteria = model.getCriteriaParentName();
+		
+		ProblemElement selectedExpert = expertSelector.getSelectedElement();
+		
+		boolean status = true;
+		
+		String[] subcriteria;
+		for(String criterion: criteria) {
+			
+			if(model.getCriterionWeight(selectedExpert.getName(), criterion) == null)
+				status = false;
+		
+			subcriteria = model.getCriterionChildrenName(criterion);
+			
+			for(String subcriterion: subcriteria) {
+				if(model.getCriterionWeight(selectedExpert.getName(), subcriterion) == null) {
+					criterionSelector.setStatus(model.getCriterion(criterion), false);
+					status = false;
+				} else 
+					criterionSelector.setStatus(model.getCriterion(criterion), true);
+			}
+		}
+		
+		expertSelector.setStatus(selectedExpert, status);
+	}
+	
+	private void createCriterionCollectorWeight(Composite leftPart) {
+		Composite body = new Composite(leftPart, SWT.NONE);
+		UiService.setGridData(body, 9, 9, true, true);
+		UiService.setGridLayout(body, 1);
+		
+		criteriaCollector = new WCollector(body);
+		criteriaCollector.setHeaders(Arrays.stream(model.getCriteriaParentName()).toArray(String[]::new));
+		addCollectorListeners(criteriaCollector);
+		addCriteriaCollectorListener();
+	}
+	
+	private void addCollectorListeners(WCollector collector) {
+		collector.setOperationListener(new WItemOperation() {
+			@Override
+			public String getModifiedValue(WEvent operationType, String before, String after) {
+				return Double.toString(DoubleHelper.NormalizeZeroToOne(before));
+			}
+		});
+	}
+	
+	private void createSubcriterionCollectorWeight(Composite leftPart) {
+		Composite body = new Composite(leftPart, SWT.NONE);
+		UiService.setGridData(body, 9, 9, true, true);
+		UiService.setGridLayout(body, 1);
+		
+		Composite criterionSelection = new Composite(body, SWT.NONE);
+		UiService.setGridData(criterionSelection, 9, 9, true, false);
+		UiService.setGridLayout(criterionSelection, 3);
+		
+		criterionSelector = new ProblemElementSelector(criterionSelection, model.getParentCriteria());
+		criterionSelector.setText(Criterion.Type);
+		criterionSelector.setListener(new IProblemElementChangedListener() {
+			@Override
+			public void problemElementChanged(ProblemElement pe) {
+				updateOperator();
+				updateSubcriteriaCollectorData(pe);
+			}
+		});
+		
+		operatorsCombo = new Combo(criterionSelection, SWT.READ_ONLY);
+		UiService.setGridData(operatorsCombo, 9, 9, false, true);
+		operatorsCombo.setItems(model.getOperatorsName());
+		operatorsCombo.select(0);
+		operatorsCombo.addSelectionListener(new SelectionAdapter() {
+			@Override
+			public void widgetSelected(SelectionEvent e) {
+				AggregationOperator operator = model.setAggregationOperator(operatorsCombo.getText(), expertSelector.getSelectedElement().getName(), 
+						criterionSelector.getSelectedElement().getName());
+				
+				if(operator instanceof IParameterizedOperator)
+					((IParameterizedOperator) operator).openDialog(criterionSelector.getSelectedElement().getChildren());
+				
+				refresh();
+			}
+		});
+		
+		subcriteriaCollector = new WCollector(body);
+		subcriteriaCollector.setHeaders(Arrays.stream(model.getCriterionChildrenName(
+				criterionSelector.getSelectedElement().getName())).toArray(String[]::new));
+		addCollectorListeners(subcriteriaCollector);
+		addSubcriteriaCollectorListener();		
+	}
+	
+	private void updateOperator() {
+		String[] operatorsName = model.getOperatorsName();
+		AggregationOperator operator = model.getAggregationOperator(expertSelector.getSelectedElement().getName(), 
+				criterionSelector.getSelectedElement().getName());
+		
+		int indexOperator = -1;
+		for(int i = 0; i < operatorsName.length; ++i) {
+			if(operatorsName[i].equals(operator.getName())) {
+				indexOperator = i;
+				break;
+			}
+		}
+		
+		operatorsCombo.select(indexOperator);
+	}
+	
+	private void updateSubcriteriaCollectorData(ProblemElement selectedCriterion) {
+	
+		checkAllCriteriaWeights();
+		
+		HashMap<String, Double> subcriteriaWeights = model.getSubcriteriaWeights(
+				expertSelector.getSelectedElement().getName(), selectedCriterion.getName());
+		
+		String[] subitems = model.getCriterionChildrenName(selectedCriterion.getName());
+
+		ArrayList<String> data = new ArrayList<>();
+
+		for (String subcriterion: subitems) {
+			Double value = subcriteriaWeights.get(subcriterion);
+			if (value != null)
+				data.add(value + ""); //$NON-NLS-1$
+		}
+		
+		subcriteriaCollector.clear();
+		subcriteriaCollector.setHeaders(Arrays.stream(model.getCriterionChildrenName(selectedCriterion.getName())).toArray(String[]::new));
+		subcriteriaCollector.setValues(data);
+	}
+	
+	private void addCriteriaCollectorListener() {
+		criteriaCollector.setChangeListener(new WItemChanged() {
+			@Override
+			public void onWidgetChange() {		
+			
+				ProblemElement selectedExpert = expertSelector.getSelectedElement();
+				
+				String[] criteria = model.getCriteriaParentName();
+				String[] data = criteriaCollector.getData();
+				
+				if(data.length == 0) //clear values
+					for (int i = 0; i < criteria.length; i++)
+						model.removeCriterionWeight(selectedExpert.getName(), criteria[i]);
+				else {
+					for (int i = 0; i < criteria.length && i < data.length; i++)
+						model.addCriterionWeight(selectedExpert.getName(), criteria[i], DoubleHelper.ParseDouble(data[i]));
+				}
+				
+				checkAllCriteriaWeights();
+				
+				refresh();
+			}
+		});
+		
+		criteriaCollector.setBeforeOperationListener(new WItemBeforeOperation() {
+			@Override
+			public boolean shouldBeExecuted(WEvent operationType, String before, String after) {
+				String[] subItems = model.getCriteriaParentName();
+				
+				if (operationType.equals(WEvent.ADD)) {
+					
+					String[] data = criteriaCollector.getData();
+
+					if(data.length == subItems.length)
+						return false;
+					
+					double sum = 0.0;
+					for(String value : data)
+						sum += Double.parseDouble(value);
+					
+					sum += DoubleHelper.NormalizeZeroToOne(before);
+					
+					if(data.length == subItems.length - 1)
+						return DoubleHelper.Equals(sum, 1.0, 5);
+					else
+						return sum <= 1.0;	
+					
+				} else if (operationType.equals(WEvent.CLEAR))
+					return true;
+
+				return false;
+			}
+		});
+	}
+	
+	private void addSubcriteriaCollectorListener() {
+		subcriteriaCollector.setChangeListener(new WItemChanged() {
+			@Override
+			public void onWidgetChange() {
+				ProblemElement selectedCriterion = criterionSelector.getSelectedElement();
+				
+				String[] subcriteria = model.getCriterionChildrenName(selectedCriterion.getName());
+				String[] data = subcriteriaCollector.getData();
+				
+				if(data.length == 0) {//clear values
+					for (int i = 0; i < subcriteria.length; i++)
+						model.removeCriterionWeight(expertSelector.getSelectedElement().getName(), subcriteria[i]);
+				} else {
+					for (int i = 0; i < subcriteria.length && i < data.length; i++)
+						model.addCriterionWeight(expertSelector.getSelectedElement().getName(), subcriteria[i], DoubleHelper.ParseDouble(data[i]));
+				}
+				
+				checkAllCriteriaWeights();
+
+				refresh();				
+			}
+		});
+		
+		subcriteriaCollector.setBeforeOperationListener(new WItemBeforeOperation() {
+			@Override
+			public boolean shouldBeExecuted(WEvent operationType, String before, String after) {
+				String[] subItems = model.getCriterionChildrenName(criterionSelector.getSelectedElement().getName());
+				
+				if (operationType.equals(WEvent.ADD)) {
+					
+					String[] data = subcriteriaCollector.getData();
+
+					if(data.length == subItems.length)
+						return false;
+					
+					double sum = 0.0;
+					for(String value : data)
+						sum += Double.parseDouble(value);
+					
+					sum += DoubleHelper.NormalizeZeroToOne(before);
+					
+					if(data.length == subItems.length - 1)
+						return DoubleHelper.Equals(sum, 1.0, 5);
+					else
+						return sum <= 1.0;	
+					
+				} else if (operationType.equals(WEvent.CLEAR))
+					return true;
+
+				return false;
+			}
+		});
+	}
+	
+	private void createExpertDecisionMatrix(Composite leftPart) {
+		Label expertDecisionMatrix = new Label(leftPart, SWT.BOLD);
+		UiService.setGridData(expertDecisionMatrix, -1, -1, false, false);
+		expertDecisionMatrix.setText("Expert decision matrix");
+		expertDecisionMatrix.setFont(JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT));
+		
+		Composite decisionMatrixExpertComposite = new Composite(leftPart, SWT.NONE);
+		UiService.setGridData(decisionMatrixExpertComposite, 9, 9, false, true);
+		UiService.setGridLayout(decisionMatrixExpertComposite, 1);
+		  
+		String[] rowHeader = model.getAlternativesNames();
+		String[] colHeader = model.getShortenedCriteriaNames();
+		String[][] valuesSTR = new String [rowHeader.length][colHeader.length];
+		
+		//Double[][] values = model.getDecisionMatrix();
+		for(int i = 0; i < valuesSTR.length; i++) {
+			for(int j = 0; j < valuesSTR[i].length; j++)
+				valuesSTR[i][j] = "";
+		}
+
+		decisionMatrixExpert = new HtmlTextTable(decisionMatrixExpertComposite, valuesSTR, colHeader, rowHeader);
+		decisionMatrixExpert.render();
+	}
+
+	private void createRightPart(Composite twoColumns) {
+		Composite rightPart = new Composite(twoColumns, SWT.BORDER);
+		UiService.setGridData(rightPart, 9, 9, true, true);
+		UiService.setGridLayout(rightPart, 1);
+		
+		Label expertsWeights = new Label(rightPart, SWT.BOLD);
+		UiService.setGridData(expertsWeights, -1, -1, false, false);
+		expertsWeights.setText("Experts weights");
+		expertsWeights.setFont(JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT));
+		
+		createExpertCollectorWeight(rightPart);
+		
+		Label decisionMatrixLabel = new Label(rightPart, SWT.BOLD);
+		UiService.setGridData(decisionMatrixLabel, -1, -1, false, false);
+		decisionMatrixLabel.setText("Decision matrix");
+		decisionMatrixLabel.setFont(JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT));
+		
+		Composite decisionMatrixComposite = new Composite(rightPart, SWT.NONE);
+		UiService.setGridData(decisionMatrixComposite, 9, 9, false, true);
+		UiService.setGridLayout(decisionMatrixComposite, 1);
+		
+		String[] rowHeader = model.getAlternativesNames();
+		String[] colHeader = model.getShortenedCriteriaNames();
+		String[][] valuesSTR = new String [rowHeader.length][colHeader.length];
+		for(int i = 0; i < valuesSTR.length; i++) {
+			for(int j = 0; j < valuesSTR[i].length; j++)
+				valuesSTR[i][j] = "";
+		}
+		
+		decisionMatrix = new HtmlTextTable(decisionMatrixComposite, valuesSTR, colHeader, rowHeader);
+		decisionMatrix.render();	
+	}
+	
+	private void createExpertCollectorWeight(Composite leftPart) {
+		Composite body = new Composite(leftPart, SWT.NONE);
+		UiService.setGridData(body, 9, 9, true, true);
+		UiService.setGridLayout(body, 1);
+		
+		WCollector expertsCollector = new WCollector(body);
+		expertsCollector.setHeaders(Arrays.stream(model.getExpertsName()).toArray(String[]::new));
+		addCollectorListeners(expertsCollector);
+		addExpertsCollectorListener(expertsCollector);
+	}
+	
+	private void addExpertsCollectorListener(WCollector expertsCollector) {
+		expertsCollector.setChangeListener(new WItemChanged() {
+			@Override
+			public void onWidgetChange() {
+				String[] experts = model.getExpertsName();
+				
+				String[] data = expertsCollector.getData();
+				
+				if(data.length == 0) {
+					for (int i = 0; i < experts.length; i++)
+						model.removeExpertWeight(experts[i]);
+				} else {
+					for (int i = 0; i < experts.length && i < data.length; i++)
+						model.addExpertWeight(experts[i], DoubleHelper.ParseDouble(data[i]));
+				}
+				
+				refresh();
+			}
+		});
+	}
+	
+	@Override
+	public void refresh() {
+		refreshExpertDecisionMatrix();
+		refreshDecisionMatrix();
+	}
+
+	private void refreshExpertDecisionMatrix() {
+		String[][] valuesSTR = new String[model.getAlternatives().length][model.getParentCriteria().length];
+		
+		if(expertSelector.getStatus(expertSelector.getSelectedElement())) {
+			FuzzyValuation[][] decisionMatrixExpert = model.computeDecisionMatrixByExpert(expertSelector.getSelectedElement());
+			
+			for(int i = 0; i < valuesSTR.length; i++) {
+				for(int j = 0; j < valuesSTR[i].length; j++)
+					valuesSTR[i][j] = decisionMatrixExpert[i][j].changeFormatValuationToString();
+			}
+			
+		} else {
+			
+			for(int i = 0; i < valuesSTR.length; i++) {
+				for(int j = 0; j < valuesSTR[i].length; j++)
+					valuesSTR[i][j] = "";
+			}
+		}
+		
+		decisionMatrixExpert.refresh(valuesSTR);
+		decisionMatrixExpert.render();
+	}
+	
+	private void refreshDecisionMatrix() {
+		String[][] valuesSTR = new String[model.getAlternatives().length][model.getParentCriteria().length];
+		
+		if(expertSelector.getStatus() && (model.getExpertsWeights().size() == model.getExperts().length)) {
+			FuzzyValuation[][] decisionCollectiveMatrix = model.computeDecisionMatrix();
+			
+			for(int i = 0; i < valuesSTR.length; i++) {
+				for(int j = 0; j < valuesSTR[i].length; j++)
+					valuesSTR[i][j] = decisionCollectiveMatrix[i][j].changeFormatValuationToString();
+			}
+			
+		} else {
+			
+			for(int i = 0; i < valuesSTR.length; i++) {
+				for(int j = 0; j < valuesSTR[i].length; j++)
+					valuesSTR[i][j] = "";
+			}
+		}
+		
+		decisionMatrix.refresh(valuesSTR);
+		decisionMatrix.render();
+		
+		this.sendRefresh();
+	}
+
+	@Override
+	protected boolean isForwardEnabled() {
+		return model.isFinished();
+	}
+
+}