Adds OPTIMUS plugin

OPTIMUS/eu.DECIDEh2020.optimus/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry exported="true" kind="lib" path="bin/"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="lib" path="D:/W/2017-Decide/workspace/json-simple-1.1.1.jar">
+		<attributes>
+			<attribute name="org.eclipse.jst.component.dependency" value="../"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jst.j2ee.internal.module.container"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

OPTIMUS/eu.DECIDEh2020.optimus/.gitignore

+bin/
+.settings/
\ No newline at end of file

OPTIMUS/eu.DECIDEh2020.optimus/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>eu.DECIDEh2020.optimus</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.wst.common.project.facet.core.builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<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>
+		<buildCommand>
+			<name>org.eclipse.wst.validation.validationbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
+		<nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
+	</natures>
+</projectDescription>

OPTIMUS/eu.DECIDEh2020.optimus/META-INF/MANIFEST.MF

+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Optimus
+Bundle-SymbolicName: eu.DECIDEh2020.optimus;singleton:=true
+Bundle-Version: 1.0.0.qualifier
+Require-Bundle: org.eclipse.jface.text,
+ org.eclipse.core.resources,
+ org.eclipse.ui,
+ org.eclipse.ui.editors,
+ org.eclipse.ui.ide,
+ org.eclipse.core.runtime,
+ com.googlecode.json-simple;bundle-version="1.1.1",
+ org.eclipse.json;bundle-version="1.0.100"
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Bundle-ClassPath: bin/

OPTIMUS/eu.DECIDEh2020.optimus/build.properties

+output.. = bin/
+bin.includes = plugin.xml,\
+               META-INF/,\
+               icons/,\
+               bin/

OPTIMUS/eu.DECIDEh2020.optimus/plugin.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.4"?>
+<plugin>
+
+   <extension
+         point="org.eclipse.ui.editors">
+      <editor
+            name="Optimus Editor"
+            extensions="json"
+            filenames="*.json"
+            icon="icons/decide.png"
+            contributorClass="eu.DECIDEh2020.optimus.editors.OptimusContributor"
+            class="eu.DECIDEh2020.optimus.editors.optimus"
+            id="eu.DECIDEh2020.optimus.editors.optimus">
+      </editor>
+   </extension>
+   <extension
+         point="org.eclipse.ui.newWizards">
+      <category
+            name="Optimus Wizards"
+            id="eu.DECIDEh2020.optimus">
+      </category>
+      <wizard
+            name="Optimus Editor file"
+            icon="icons/decide.png"
+            category="eu.DECIDEh2020.optimus"
+            class="eu.DECIDEh2020.optimus.wizards.OptimusWizard"
+            id="eu.DECIDEh2020.optimus.wizards.OptimusWizard">
+      </wizard>
+   </extension>
+
+</plugin>

OPTIMUS/eu.DECIDEh2020.optimus/src/META-INF/MANIFEST.MF

+Manifest-Version: 1.0
+Class-Path: 
+

OPTIMUS/eu.DECIDEh2020.optimus/src/eu/DECIDEh2020/optimus/editors/Classification.java

+
+/*********************************************************************
+* Copyright (c) 2017 Tecnalia.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* SPDX-License-Identifier: EPL-2.0
+* Contributors (in alphabetical order):
+* Gorka Benguria                            Tecnalia
+* Iaki Etxaniz                             Tecnalia
+* Juncal Alonso                             Tecnalia
+* Leire Orue-Echevarria                     Tecnalia
+* Maria Jose Lopez                          Tecnalia
+* Marisa Escalante                          Tecnalia
+* Initially developed in the context of DECIDE EU project www.DECIDE-h2020.eu
+**********************************************************************/
+package eu.DECIDEh2020.optimus.editors;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.custom.ScrolledComposite;
+import org.eclipse.swt.custom.StyledText;
+import org.eclipse.swt.events.ControlAdapter;
+import org.eclipse.swt.events.ControlEvent;
+import org.eclipse.swt.events.FocusEvent;
+import org.eclipse.swt.events.FocusListener;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.graphics.Font;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
+import org.json.simple.JSONArray;
+//import org.json.simple.JSONException;
+import org.json.simple.JSONObject;
+
+import java.awt.Rectangle;
+//import org.json.parser.JSONParser;
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+
+public class Classification extends Composite {
+
+	/**
+	 * Create the composite.
+	 * @param parent
+	 * @param style
+	 */
+
+	/** The text widget used in page 2. */
+	private StyledText text;
+	/** The font chosen in page 1. */
+	private Font font;
+	private Text text_1;
+	private Composite text_2;
+	public int microservicesNumber = 0;
+
+	public int y = 5;
+	public String newcontent;
+
+
+	
+	public Classification(Composite parent, int style) {
+		super(parent, style);
+		
+		
+		Label lblAppName = new Label(this, SWT.NONE);
+		lblAppName.setBounds(10, 10, 55, 15);
+		lblAppName.setText("App name");
+		
+		text_1 = new Text(this, SWT.BORDER);
+		text_1.setBounds(74, 10, 76, 21);
+		
+		text_1.addFocusListener(new FocusListener() {
+		
+			@Override
+			public void focusGained(FocusEvent arg0) {
+				// TODO Auto-generated method stub
+				
+			}
+
+			@Override
+			public void focusLost(FocusEvent arg0) {
+				newcontent = text_1.getText();
+    			optimus.appjson.put("id", (int) (Math.random()*1000));
+    			optimus.appjson.put("name", newcontent);
+			
+			}});
+		
+		
+
+		
+		
+		Button btnAddMicroservice = new Button(this, SWT.NONE);
+		btnAddMicroservice.setBounds(181, 10, 130, 25);
+		btnAddMicroservice.setText("Add microservice");
+		
+		ScrolledComposite scrolledComposite = new ScrolledComposite(this, SWT.BORDER | SWT.V_SCROLL);
+		scrolledComposite.setExpandHorizontal(true);
+		scrolledComposite.setTouchEnabled(true);
+		scrolledComposite.setShowFocusedControl(true);
+		scrolledComposite.setAlwaysShowScrollBars(true);
+		scrolledComposite.setBounds(10, 48, 753, 596);
+		
+		scrolledComposite.setMinHeight(y);
+
+		final StyledText styledText = new StyledText(scrolledComposite, SWT.BORDER | SWT.WRAP);
+		 scrolledComposite.setContent(styledText);
+		    scrolledComposite.setMinSize(styledText.computeSize(SWT.DEFAULT, SWT.DEFAULT));
+		    
+		    Button btnSave = new Button(this, SWT.NONE);
+		    btnSave.setBounds(688, 660, 75, 25);
+		    btnSave.setText("Save");
+		    
+		    btnSave.addSelectionListener(new SelectionAdapter() {
+		    	public void widgetSelected(SelectionEvent event) {
+		    		
+		    		optimus.appjson.put("microservices", optimus.appmicros);
+		    		final String FILENAME = optimus.workingDir;
+		    		
+		    			BufferedWriter bw = null;
+		    			FileWriter fw = null;
+		    			try {
+		    				String content = optimus.appjson.toString();
+		    				fw = new FileWriter(FILENAME);
+		    				bw = new BufferedWriter(fw);
+		    				bw.write(content);
+		    			} catch (IOException e) {
+		    				e.printStackTrace();
+		    			} finally {
+		    				try {
+		    					if (bw != null)
+		    						bw.close();
+		    					if (fw != null)
+		    						fw.close();
+
+		    				} catch (IOException ex) {
+		    					ex.printStackTrace();
+		    				}
+		    		}
+		    	}
+		    });
+		
+		
+		    
+		    
+
+		btnAddMicroservice.addSelectionListener(new SelectionAdapter() {
+		public void widgetSelected(SelectionEvent event) {
+			microservicesNumber = microservicesNumber + 1;
+			//scrolledComposite.setMinHeight(y);
+			text_2 = new Microservice(scrolledComposite, SWT.BORDER, y);
+			text_2.setBounds(10, y, 500, 100);
+			y = (120* microservicesNumber);
+
+		}
+	});
+
+	}
+    public void Create_microservices_from_file() {
+		if (!(optimus.appjson.isEmpty()))
+		{
+    	text_1.setText(optimus.appjson.get("name").toString());
+    	ScrolledComposite scrolledComposite = new ScrolledComposite(this, SWT.BORDER | SWT.V_SCROLL);
+		scrolledComposite.setTouchEnabled(true);
+		scrolledComposite.setShowFocusedControl(true);
+		scrolledComposite.setAlwaysShowScrollBars(true);
+		scrolledComposite.setExpandVertical(true);
+		scrolledComposite.setBounds(10, 48, 753, 427);
+
+    	optimus.appjson.get("name").toString();
+    	optimus.appmicros.remove("microservices");
+    	optimus.appmicros.add(optimus.appjson.get("microservices"));
+    	int numbermicr=optimus.appmicros.size();
+     	for (int i = 0; i <numbermicr; i++)
+    	
+    	{
+		microservicesNumber = microservicesNumber + 1;
+		text_2 = new Microservice(scrolledComposite, SWT.BORDER, y);
+		text_2.setBounds(10, y, 500, 100);
+		y = (120* microservicesNumber);
+   // }
+    	}
+		}
+	}	
+	@Override
+	protected void checkSubclass() {
+		// Disable the check that prevents subclassing of SWT components
+	}
+}

OPTIMUS/eu.DECIDEh2020.optimus/src/eu/DECIDEh2020/optimus/editors/Microservice.java

+
+/*********************************************************************
+* Copyright (c) 2017 Tecnalia.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* SPDX-License-Identifier: EPL-2.0
+* Contributors (in alphabetical order):
+* Gorka Benguria                            Tecnalia
+* Iaki Etxaniz                             Tecnalia
+* Juncal Alonso                             Tecnalia
+* Leire Orue-Echevarria                     Tecnalia
+* Maria Jose Lopez                          Tecnalia
+* Marisa Escalante                          Tecnalia
+* Initially developed in the context of DECIDE EU project www.DECIDE-h2020.eu
+**********************************************************************/
+package eu.DECIDEh2020.optimus.editors;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.custom.StyledText;
+import org.eclipse.swt.events.FocusEvent;
+import org.eclipse.swt.events.FocusListener;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.graphics.Font;
+import org.eclipse.swt.graphics.FontData;
+import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.FontDialog;
+import org.eclipse.swt.custom.ScrolledComposite;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
+import org.json.simple.JSONArray;
+
+import org.json.simple.JSONObject;
+import org.eclipse.swt.widgets.Combo;
+
+
+public class Microservice extends Composite {
+
+	/**
+	 * Create the composite.
+	 * @param parent
+	 * @param style
+	 */
+	/** The text widget used in page 2. */
+	private StyledText text;
+	/** The font chosen in page 1. */
+	private Font font;
+	private Text text_1;
+	private Text text_2;
+	private static JSONObject micros;
+	private JSONArray DetachR;
+	private Text Detach_text;
+	private JSONObject DRes;
+	
+
+	
+	public Microservice(Composite parent, int style, int y) {
+		super(parent, style);
+		
+		Composite compositeMicro = new Composite(this, SWT.NONE);
+		compositeMicro.setBounds(1, 0, 437, 83);
+		DetachR = new JSONArray();
+		
+			Label lblMicroserviceName = new Label(compositeMicro, SWT.NONE);
+			lblMicroserviceName.setBounds(10, 13, 50, 30);
+			lblMicroserviceName.setText("Name");
+			text_2 = new Text(compositeMicro, SWT.BORDER);
+			text_2.setBounds(69, 13, 200, 21);
+			
+			Label microserviceID = new Label(compositeMicro, SWT.NONE);
+			microserviceID.setText("id");
+			microserviceID.setBounds(275, 13, 50, 15);
+			microserviceID.setVisible(false);
+			
+			
+			
+			Combo ms_type = new Combo(compositeMicro, SWT.NONE);
+			ms_type.setItems(new String[] {"Computing", "Computing Public IP"});
+			ms_type.setBounds(331, 10, 91, 23);
+			ms_type.setText("Computing");
+			
+			Combo Detach_type = new Combo(compositeMicro, SWT.NONE);
+			Detach_type.setItems(new String[] {"Storage. DB", "Storage", "Queue System"});
+			Detach_type.setBounds(322, 50, 91, 23);
+			Detach_type.setText("Storage");
+			
+			Button Det_DB = new Button(compositeMicro, SWT.RADIO);
+			Det_DB.setSelection(false);
+			Det_DB.setBounds(277, 53, 90, 16);
+			Det_DB.setText("DB");
+			Det_DB.addFocusListener(new FocusListener(){
+		    	
+
+				@Override
+				public void focusGained(FocusEvent arg0) {
+					// TODO Auto-generated method stub
+					
+				}
+				@Override
+				public void focusLost(FocusEvent arg0) {
+					if (Det_DB.getSelection()) {
+						Detach_type.setText("Storage. DB");
+											} 
+					if (!Det_DB.getSelection()) {Detach_type.setText("Storage");}
+					
+					if (DRes.get(Detach_type)!=Detach_type.getText())
+					{
+						
+						DetachR.remove(DRes);
+						micros.remove(DetachR);
+						optimus.appmicros.remove(micros);
+						DRes.put("Det_type",Detach_type.getText());
+						DetachR.add(DRes);
+						optimus.appmicros.add(micros);
+					}
+					
+					
+
+					
+				}
+			}
+					);
+			
+			Label lblDetachableResource = new Label(compositeMicro, SWT.NONE);
+			lblDetachableResource.setBounds(11, 53, 122, 15);
+			lblDetachableResource.setText("Detachable Resource");
+			Detach_text = new Text(compositeMicro, SWT.BORDER);
+			Detach_text.setBounds(143, 47, 117, 21);
+
+			Detach_text.addFocusListener(new FocusListener(){
+		    	
+
+				@Override
+				public void focusGained(FocusEvent arg0) {
+					// TODO Auto-generated method stub
+					
+				}
+
+				@Override
+				public void focusLost(FocusEvent arg0) {
+					DRes = new JSONObject();
+					for (int i=0; i < optimus.appmicros.size(); i++)
+						{
+						    JSONObject itemArr = (JSONObject)optimus.appmicros.get(i);
+						    if (itemArr.get("id").equals(microserviceID.getText()))
+						    {
+						        break;
+						    }
+					}
+					 
+					DRes.put("DetachableResource",Detach_text.getText());
+					DRes.put("Det_type",Detach_type.getText());
+					
+					DetachR.add(DRes);
+					micros.put("Detachable_resources",DetachR);
+				}
+			});
+						
+			text_2.addFocusListener(new FocusListener() {
+		    	
+
+				@Override
+				public void focusGained(FocusEvent arg0) {
+					// TODO Auto-generated method stub
+					
+				}
+
+				@Override
+				public void focusLost(FocusEvent arg0) {
+					int id = (int) (Math.random()*1000);
+					String idS = String.valueOf(id);
+					micros = new JSONObject();
+
+						for (int i=0; i < optimus.appmicros.size(); i++)
+						{
+						    JSONObject itemArr = (JSONObject)optimus.appmicros.get(i);
+						    if (itemArr.get("id").equals(microserviceID.getText()))
+						    {
+						    	optimus.appmicros.remove(itemArr);
+						    	idS = microserviceID.getText();
+						        break;
+
+						    }
+					}
+					 
+					
+					micros.put("id",idS);
+					micros.put("microname", text_2.getText());
+					micros.put("ms_type", ms_type.getText());
+					optimus.appmicros.add(micros);
+					microserviceID.setText(idS);
+					microserviceID.setVisible(true);
+				}
+
+				private boolean existmicroservice(String text) {
+					JSONObject microstemp = new JSONObject();
+					microstemp.put("id",text);
+					microstemp.put("microname", text_2.getText());
+					if (optimus.appmicros.contains(microstemp)) {
+						return true;
+
+					} else {
+					return false;
+					}
+				}});
+		}
+	//});
+
+	//}
+
+	@Override
+	protected void checkSubclass() {
+		// Disable the check that prevents subclassing of SWT components
+	}
+}

OPTIMUS/eu.DECIDEh2020.optimus/src/eu/DECIDEh2020/optimus/editors/OptimusContributor.java

+
+/*********************************************************************
+* Copyright (c) 2017 Tecnalia.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* SPDX-License-Identifier: EPL-2.0
+* Contributors (in alphabetical order):
+* Gorka Benguria                            Tecnalia
+* Iaki Etxaniz                             Tecnalia
+* Juncal Alonso                             Tecnalia
+* Leire Orue-Echevarria                     Tecnalia
+* Maria Jose Lopez                          Tecnalia
+* Marisa Escalante                          Tecnalia
+* Initially developed in the context of DECIDE EU project www.DECIDE-h2020.eu
+**********************************************************************/
+package eu.DECIDEh2020.optimus.editors;
+
+import org.eclipse.jface.action.*;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.ui.IActionBars;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IWorkbenchActionConstants;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.actions.ActionFactory;
+import org.eclipse.ui.ide.IDE;
+import org.eclipse.ui.ide.IDEActionFactory;
+import org.eclipse.ui.part.MultiPageEditorActionBarContributor;
+import org.eclipse.ui.texteditor.ITextEditor;
+import org.eclipse.ui.texteditor.ITextEditorActionConstants;
+
+/**
+ * Manages the installation/deinstallation of global actions for multi-page editors.
+ * Responsible for the redirection of global actions to the active editor.
+ * Multi-page contributor replaces the contributors for the individual editors in the multi-page editor.
+ */
+public class OptimusContributor extends MultiPageEditorActionBarContributor {
+	private IEditorPart activeEditorPart;
+	private Action sampleAction;
+	/**
+	 * Creates a multi-page contributor.
+	 */
+	public OptimusContributor() {
+		super();
+		createActions();
+	}
+	/**
+	 * Returns the action registed with the given text editor.
+	 * @return IAction or null if editor is null.
+	 */
+	protected IAction getAction(ITextEditor editor, String actionID) {
+		return (editor == null ? null : editor.getAction(actionID));
+	}
+	/* (non-JavaDoc)
+	 * Method declared in AbstractMultiPageEditorActionBarContributor.
+	 */
+
+	public void setActivePage(IEditorPart part) {
+		if (activeEditorPart == part)
+			return;
+
+		activeEditorPart = part;
+
+		IActionBars actionBars = getActionBars();
+		if (actionBars != null) {
+
+			ITextEditor editor = (part instanceof ITextEditor) ? (ITextEditor) part : null;
+
+			actionBars.setGlobalActionHandler(
+				ActionFactory.DELETE.getId(),
+				getAction(editor, ITextEditorActionConstants.DELETE));
+			actionBars.setGlobalActionHandler(
+				ActionFactory.UNDO.getId(),
+				getAction(editor, ITextEditorActionConstants.UNDO));
+			actionBars.setGlobalActionHandler(
+				ActionFactory.REDO.getId(),
+				getAction(editor, ITextEditorActionConstants.REDO));
+			actionBars.setGlobalActionHandler(
+				ActionFactory.CUT.getId(),
+				getAction(editor, ITextEditorActionConstants.CUT));
+			actionBars.setGlobalActionHandler(
+				ActionFactory.COPY.getId(),
+				getAction(editor, ITextEditorActionConstants.COPY));
+			actionBars.setGlobalActionHandler(
+				ActionFactory.PASTE.getId(),
+				getAction(editor, ITextEditorActionConstants.PASTE));
+			actionBars.setGlobalActionHandler(
+				ActionFactory.SELECT_ALL.getId(),
+				getAction(editor, ITextEditorActionConstants.SELECT_ALL));
+			actionBars.setGlobalActionHandler(
+				ActionFactory.FIND.getId(),
+				getAction(editor, ITextEditorActionConstants.FIND));
+			actionBars.setGlobalActionHandler(
+				IDEActionFactory.BOOKMARK.getId(),
+				getAction(editor, IDEActionFactory.BOOKMARK.getId()));
+			actionBars.updateActionBars();
+		}
+	}
+	private void createActions() {
+		sampleAction = new Action() {
+			public void run() {
+				MessageDialog.openInformation(null, "Optimus", "Sample Action Executed");
+			}
+		};
+		sampleAction.setText("Sample Action");
+		sampleAction.setToolTipText("Sample Action tool tip");
+		sampleAction.setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().
+				getImageDescriptor(IDE.SharedImages.IMG_OBJS_TASK_TSK));
+	}
+	public void contributeToMenu(IMenuManager manager) {
+		IMenuManager menu = new MenuManager("Editor &Menu");
+		manager.prependToGroup(IWorkbenchActionConstants.MB_ADDITIONS, menu);
+		menu.add(sampleAction);
+	}
+	public void contributeToToolBar(IToolBarManager manager) {
+		manager.add(new Separator());
+		manager.add(sampleAction);
+	}
+}

OPTIMUS/eu.DECIDEh2020.optimus/src/eu/DECIDEh2020/optimus/editors/Simulation.java

+
+/*********************************************************************
+* Copyright (c) 2017 Tecnalia.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* SPDX-License-Identifier: EPL-2.0
+* Contributors (in alphabetical order):
+* Gorka Benguria                            Tecnalia
+* Iaki Etxaniz                             Tecnalia
+* Juncal Alonso                             Tecnalia
+* Leire Orue-Echevarria                     Tecnalia
+* Maria Jose Lopez                          Tecnalia
+* Marisa Escalante                          Tecnalia
+* Initially developed in the context of DECIDE EU project www.DECIDE-h2020.eu
+**********************************************************************/
+package eu.DECIDEh2020.optimus.editors;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.DisposeEvent;
+import org.eclipse.swt.events.DisposeListener;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.widgets.Composite;
+//import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Button;
+//import org.eclipse.swt.widgets.Table;
+import org.json.simple.JSONArray;
+//import org.json.simple.JSONObject;
+import org.eclipse.swt.widgets.ProgressBar;
+import org.eclipse.swt.custom.StyledText;
+import org.eclipse.swt.widgets.Group;
+import org.eclipse.swt.custom.ScrolledComposite;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.wb.swt.SWTResourceManager;
+
+public class Simulation extends Composite {
+
+
+
+	/**
+	 * Create the composite.
+	 * @param parent
+	 * @param style
+	 */
+	
+	private JSONArray NFRs;
+	public Simulation(Composite parent, int style) {
+		super(parent, SWT.NONE);
+		
+		ScrolledComposite scrolledComposite = new ScrolledComposite(this, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
+		scrolledComposite.setAlwaysShowScrollBars(true);
+		scrolledComposite.setBounds(10, 43, 813, 453);
+		scrolledComposite.setExpandHorizontal(true);
+		scrolledComposite.setExpandVertical(true);
+		
+		Group group = new Group(scrolledComposite, SWT.NONE);
+		
+		Composite composite = new Composite(group, SWT.NONE);
+		composite.setBounds(10, 10, 135, 121);
+		
+		Label lblNfrEditor = new Label(composite, SWT.NONE);
+		lblNfrEditor.setBounds(10, 10, 55, 15);
+		lblNfrEditor.setText("NFR Editor");
+		NFRs = new JSONArray();
+		
+		
+		Button btnCost_1 = new Button(composite, SWT.CHECK);
+		btnCost_1.setBounds(30, 31, 93, 16);
+		btnCost_1.setText("Cost");
+		
+		
+		Button btnAvailability_1 = new Button(composite, SWT.CHECK);
+		btnAvailability_1.setBounds(30, 53, 93, 16);
+		btnAvailability_1.setText("Availability");
+		
+		
+		Button btnLocation_1 = new Button(composite, SWT.CHECK);
+		btnLocation_1.setBounds(30, 75, 93, 16);
+		btnLocation_1.setText("Location");
+		
+		
+		Button btnSimulate = new Button(group, SWT.NONE);
+		btnSimulate.setBounds(185, 62, 75, 25);
+		btnSimulate.setText("Simulate");
+		
+		Composite composite_1 = new Composite(group, SWT.NONE);
+		composite_1.setBounds(10, 137, 723, 259);
+		
+		Label lblNewLabel = new Label(composite_1, SWT.NONE);
+		lblNewLabel.setFont(SWTResourceManager.getFont("Calibri", 14, SWT.BOLD));
+		lblNewLabel.setBounds(10, 10, 339, 21);
+		lblNewLabel.setText("ApplicationDescription JSON file:");
+		StyledText simulationText = new StyledText(composite_1, SWT.BORDER);
+		simulationText.setBounds(10, 62, 671, 100);
+		simulationText.setAlwaysShowScrollBars(true);
+		simulationText.setJustify(true);
+		simulationText.setLineSpacing(3);
+		simulationText.setText("");
+
+		btnSimulate.addSelectionListener(new SelectionAdapter() {
+		public void widgetSelected(SelectionEvent event) {
+			NFRs.removeAll(NFRs);
+			if (btnCost_1.getSelection()) {
+				NFRs.add(btnCost_1.getText());
+				}
+			if (btnAvailability_1.getSelection()) {
+				NFRs.add(btnAvailability_1.getText());
+				}
+			if (btnLocation_1.getSelection()) {
+				NFRs.add(btnLocation_1.getText());
+				}
+			
+			optimus.appjson.put("NFRs", NFRs);
+			//}
+			
+			
+
+			ProgressBar progressBar = new ProgressBar(parent, SWT.NONE);
+			progressBar.setBounds(103, 18, 170, 17);
+
+			
+			
+			progressBar.setVisible(true);
+			simulationText.setText(optimus.appjson.toString());
+			addDisposeListener(new DisposeListener() {
+				public void widgetDisposed(DisposeEvent e) {
+				}
+			});
+			
+		}
+	});
+		scrolledComposite.setContent(group);
+		scrolledComposite.setMinSize(group.computeSize(SWT.DEFAULT, SWT.DEFAULT));
+
+	}
+}

OPTIMUS/eu.DECIDEh2020.optimus/src/eu/DECIDEh2020/optimus/editors/optimus.java

+
+/*********************************************************************
+* Copyright (c) 2017 Tecnalia.
+*
+* This program and the accompanying materials are made
+* available under the terms of the Eclipse Public License 2.0
+* which is available at https://www.eclipse.org/legal/epl-2.0/
+*
+* SPDX-License-Identifier: EPL-2.0
+* Contributors (in alphabetical order):
+* Gorka Benguria                            Tecnalia
+* Iaki Etxaniz                             Tecnalia
+* Juncal Alonso                             Tecnalia
+* Leire Orue-Echevarria                     Tecnalia
+* Maria Jose Lopez                          Tecnalia
+* Marisa Escalante                          Tecnalia
+* Initially developed in the context of DECIDE EU project www.DECIDE-h2020.eu
+**********************************************************************/
+package eu.DECIDEh2020.optimus.editors;
+
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.text.Collator;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.StringTokenizer;
+
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.resources.IResourceChangeEvent;
+import org.eclipse.core.resources.IResourceChangeListener;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jface.dialogs.ErrorDialog;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.custom.StyledText;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.graphics.Font;
+import org.eclipse.swt.graphics.FontData;
+import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.FontDialog;
+import org.eclipse.ui.*;
+import org.eclipse.ui.editors.text.TextEditor;
+import org.eclipse.ui.part.FileEditorInput;
+import org.eclipse.ui.part.MultiPageEditorPart;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+import org.json.simple.JSONArray;
+import org.json.*;
+import org.eclipse.ui.ide.IDE;
+
+/**
+ * How to create a multi-page editor.
+ * This example has 3 pages:
+ * <ul>
+ * <li>page 0 contains a nested text editor.
+ * <li>page 1 shows the Classification tab
+ * <li>page 2 shows the Simulation tab
+ * </ul>
+ */
+public class optimus extends MultiPageEditorPart implements IResourceChangeListener{
+
+	/** The text editor used in page 0. */
+	// Tecnalia20171024: I should find out how to assign a json editor
+	public static TextEditor editor;
+	private StyledText text;
+	// create a json object
+	public static JSONObject appjson;
+	public static JSONArray appmicros;
+	public static String newjson = "";
+	public static String workingDir;
+	/**
+	 * Creates a multi-page editor example.
+	 */
+	public optimus() {
+		super();
+		
+		ResourcesPlugin.getWorkspace().addResourceChangeListener(this);
+		
+		appjson = new JSONObject();
+		appmicros = new JSONArray();
+		
+	}
+	/**
+	 * Creates page 0 of the multi-page editor,
+	 * which contains a text editor.
+	 */
+	void createPage0() {
+		try {
+
+			editor = new TextEditor();
+			int index = addPage(editor, getEditorInput());
+
+			setPageText(index, editor.getTitle());
+			
+		} catch (PartInitException e) {
+			ErrorDialog.openError(
+				getSite().getShell(),
+				"Error creating nested text editor",
+				null,
+				e.getStatus());
+		}
+
+	}
+	// these lines of comments are a try of reading the JSON file and drawing the corresponding elements in classification tab
+	// I leave it to try again for the second version - Mara Jos Lpe< - TECNALIA November 2017
+
+//	private JSONObject initialfile() throws IOException, ParseException {
+//		
+//		String line;
+//		FileReader f = new FileReader(workingDir);
+//        BufferedReader b = new BufferedReader(f);
+//       line = b.readLine();
+//       JSONParser parser = new JSONParser();
+//       JSONObject jsonfilecontent = (JSONObject) parser.parse(line);
+//       //JSONObject jsonfilecontent = new JSONObject(line);
+//       b.close();
+//		return jsonfilecontent;
+//	}
+	/**
+	 * Creates page 1 of the multi-page editor,
+	 * which allows you to change the font used in page 2.
+	 */
+	// Tecnalia: The UI for the classification tool
+	void createPage1() {
+
+		Composite composite = new Classification(getContainer(), SWT.NONE);
+
+		int index = addPage(composite);
+		setPageText(index, "Classification");
+	}
+	/**
+	 * Creates page 2 of the multi-page editor,
+	 * which shows the sorted text.
+	 */
+	void createPage2() {
+// Classification tab
+		Composite composite = new Simulation (getContainer(), SWT.NONE);
+
+		int index = addPage(composite);
+		setPageText(index, "Simulation");
+	}
+	
+
+	
+	
+	/**
+	 * Creates the pages of the multi-page editor.
+	 */
+	protected void createPages() {
+		createPage0();
+		createPage1();
+		createPage2();
+	}
+	/**
+	 * The <code>MultiPageEditorPart</code> implementation of this 
+	 * <code>IWorkbenchPart</code> method disposes all nested editors.
+	 * Subclasses may extend.
+	 */
+	public void dispose() {
+		ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
+		super.dispose();
+	}
+	/**
+	 * Saves the multi-page editor's document.
+	 */
+	public void doSave(IProgressMonitor monitor) {
+		getEditor(0).doSave(monitor);
+
+		
+	}
+	/**
+	 * Saves the multi-page editor's document as another file.
+	 * Also updates the text for page 0's tab, and updates this multi-page editor's input
+	 * to correspond to the nested editor's.
+	 */
+	public void doSaveAs() {
+		IEditorPart editor = getEditor(0);
+		editor.doSaveAs();
+		setPageText(0, editor.getTitle());
+		setInput(editor.getEditorInput());
+	}
+	/* (non-Javadoc)
+	 * Method declared on IEditorPart
+	 */
+	public void gotoMarker(IMarker marker) {
+		setActivePage(0);
+		IDE.gotoMarker(getEditor(0), marker);
+	}
+	/**
+	 * The <code>MultiPageEditorExample</code> implementation of this method
+	 * checks that the input is an instance of <code>IFileEditorInput</code>.
+	 */
+	public void init(IEditorSite site, IEditorInput editorInput)
+		throws PartInitException {
+		
+		if (!(editorInput instanceof IFileEditorInput))
+			throw new PartInitException("Invalid Input: Must be IFileEditorInput");
+		workingDir = ResourcesPlugin.getWorkspace().getRoot().getLocation().toString();
+		Integer position = editorInput.toString().indexOf("/");
+		Integer length = editorInput.toString().length();
+		workingDir = workingDir+editorInput.toString().substring(position,length-1);
+		
+		super.init(site, editorInput);
+	}
+	/* (non-Javadoc)
+	 * Method declared on IEditorPart.
+	 */
+	public boolean isSaveAsAllowed() {
+		return true;
+	}
+	/**
+	 * Calculates the contents of page 0.
+	 */
+	protected void pageChange(int newPageIndex) {
+		super.pageChange(newPageIndex);
+		if (newPageIndex == 1) {
+		}
+		if (newPageIndex == 2) {
+		}
+		if (newPageIndex == 0) {
+			// I do not know why but  I do not see the new content until the button save is selected.
+			// to be analyzed for next version
+			//IEditorPart editor = getEditor(0);
+			//setPageText(0, editor.getTitle());
+			//setInput(editor.getEditorInput());
+		}
+		}
+	
+	/**
+	 * Closes all project files on project close.
+	 */
+	public void resourceChanged(final IResourceChangeEvent event){
+		if(event.getType() == IResourceChangeEvent.PRE_CLOSE){
+			Display.getDefault().asyncExec(new Runnable(){
+				public void run(){
+					IWorkbenchPage[] pages = getSite().getWorkbenchWindow().getPages();
+					for (int i = 0; i<pages.length; i++){
+						if(((FileEditorInput)editor.getEditorInput()).getFile().getProject().equals(event.getResource())){
+							IEditorPart editorPart = pages[i].findEditor(editor.getEditorInput());
+							pages[i].closeEditor(editorPart,true);
+						}
+					}
+				}            
+			});
+		}
+	}
+}

OPTIMUS/eu.DECIDEh2020.optimus/src/eu/DECIDEh2020/optimus/wizards/OptimusWizard.java

+package eu.DECIDEh2020.optimus.wizards;
+
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.wizard.Wizard;
+import org.eclipse.ui.INewWizard;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.core.runtime.*;
+import org.eclipse.jface.operation.*;
+import java.lang.reflect.InvocationTargetException;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.core.resources.*;
+import org.eclipse.core.runtime.CoreException;
+import java.io.*;
+import org.eclipse.ui.*;
+import org.eclipse.ui.ide.IDE;
+
+/**
+ * This is a sample new wizard. Its role is to create a new file 
+ * resource in the provided container. If the container resource
+ * (a folder or a project) is selected in the workspace 
+ * when the wizard is opened, it will accept it as the target
+ * container. The wizard creates one file with the extension
+ * "json". If a sample multi-page editor (also available
+ * as a template) is registered for the same extension, it will
+ * be able to open it.
+ */
+
+public class OptimusWizard extends Wizard implements INewWizard {
+	private OptimusWizardPage page;
+	private ISelection selection;
+
+	/**
+	 * Constructor for OptimusWizard.
+	 */
+	public OptimusWizard() {
+		super();
+		setNeedsProgressMonitor(true);
+	}
+	
+	/**
+	 * Adding the page to the wizard.
+	 */
+	@Override
+	public void addPages() {
+		page = new OptimusWizardPage(selection);
+		addPage(page);
+	}
+
+	/**
+	 * This method is called when 'Finish' button is pressed in
+	 * the wizard. We will create an operation and run it
+	 * using wizard as execution context.
+	 */
+	@Override
+	public boolean performFinish() {
+		final String containerName = page.getContainerName();
+		final String fileName = page.getFileName();
+		IRunnableWithProgress op = new IRunnableWithProgress() {
+			public void run(IProgressMonitor monitor) throws InvocationTargetException {
+				try {
+					doFinish(containerName, fileName, monitor);
+				} catch (CoreException e) {
+					throw new InvocationTargetException(e);
+				} finally {
+					monitor.done();
+				}
+			}
+		};
+		try {
+			getContainer().run(true, false, op);
+		} catch (InterruptedException e) {
+			return false;
+		} catch (InvocationTargetException e) {
+			Throwable realException = e.getTargetException();
+			MessageDialog.openError(getShell(), "Error", realException.getMessage());
+			return false;
+		}
+		return true;
+	}
+	
+	/**
+	 * The worker method. It will find the container, create the
+	 * file if missing or just replace its contents, and open
+	 * the editor on the newly created file.
+	 */
+
+	private void doFinish(
+		String containerName,
+		String fileName,
+		IProgressMonitor monitor)
+		throws CoreException {
+		// create a sample file
+		monitor.beginTask("Creating " + fileName, 2);
+		IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
+		IResource resource = root.findMember(new Path(containerName));
+		if (!resource.exists() || !(resource instanceof IContainer)) {
+			throwCoreException("Container \"" + containerName + "\" does not exist.");
+		}
+		IContainer container = (IContainer) resource;
+		final IFile file = container.getFile(new Path(fileName));
+		try {
+			InputStream stream = openContentStream();
+			if (file.exists()) {
+				file.setContents(stream, true, true, monitor);
+			} else {
+				file.create(stream, true, monitor);
+			}
+			stream.close();
+		} catch (IOException e) {
+		}
+		monitor.worked(1);
+		monitor.setTaskName("Opening file for editing...");
+		getShell().getDisplay().asyncExec(new Runnable() {
+			public void run() {
+				IWorkbenchPage page =
+					PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
+				try {
+					IDE.openEditor(page, file, true);
+				} catch (PartInitException e) {
+				}
+			}
+		});
+		monitor.worked(1);
+	}
+	
+	/**
+	 * We will initialize file contents with a sample text.
+	 */
+
+	private InputStream openContentStream() {
+		String contents =
+			"This is the initial file contents for *.json file that should be word-sorted in the Preview page of the multi-page editor";
+		return new ByteArrayInputStream(contents.getBytes());
+	}
+
+	private void throwCoreException(String message) throws CoreException {
+		IStatus status =
+			new Status(IStatus.ERROR, "eu.DECIDEh2020.optimus", IStatus.OK, message, null);
+		throw new CoreException(status);
+	}
+
+	/**
+	 * We will accept the selection in the workbench to see if
+	 * we can initialize from it.
+	 * @see IWorkbenchWizard#init(IWorkbench, IStructuredSelection)
+	 */
+	@Override
+	public void init(IWorkbench workbench, IStructuredSelection selection) {
+		this.selection = selection;
+	}
+}
\ No newline at end of file

OPTIMUS/eu.DECIDEh2020.optimus/src/eu/DECIDEh2020/optimus/wizards/OptimusWizardPage.java

+package eu.DECIDEh2020.optimus.wizards;
+
+import org.eclipse.core.resources.IContainer;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.wizard.WizardPage;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.dialogs.ContainerSelectionDialog;
+
+/**
+ * The "New" wizard page allows setting the container for the new file as well
+ * as the file name. The page will only accept file name without the extension
+ * OR with the extension that matches the expected one (json).
+ */
+
+public class OptimusWizardPage extends WizardPage {
+	private Text containerText;
+
+	private Text fileText;
+
+	private ISelection selection;
+
+	/**
+	 * Constructor for SampleNewWizardPage.
+	 * 
+	 * @param pageName
+	 */
+	public OptimusWizardPage(ISelection selection) {
+		super("wizardPage");
+		setTitle("Multi-page Editor File");
+		setDescription("This wizard creates a new file with *.json extension that can be opened by a multi-page editor.");
+		this.selection = selection;
+	}
+
+	@Override
+	public void createControl(Composite parent) {
+		Composite container = new Composite(parent, SWT.NULL);
+		GridLayout layout = new GridLayout();
+		container.setLayout(layout);
+		layout.numColumns = 3;
+		layout.verticalSpacing = 9;
+		Label label = new Label(container, SWT.NULL);
+		label.setText("&Container:");
+
+		containerText = new Text(container, SWT.BORDER | SWT.SINGLE);
+		GridData gd = new GridData(GridData.FILL_HORIZONTAL);
+		containerText.setLayoutData(gd);
+		containerText.addModifyListener(new ModifyListener() {
+			@Override
+			public void modifyText(ModifyEvent e) {
+				dialogChanged();
+			}
+		});
+
+		Button button = new Button(container, SWT.PUSH);
+		button.setText("Browse...");
+		button.addSelectionListener(new SelectionAdapter() {
+			public void widgetSelected(SelectionEvent e) {
+				handleBrowse();
+			}
+		});
+		label = new Label(container, SWT.NULL);
+		label.setText("&File name:");
+
+		fileText = new Text(container, SWT.BORDER | SWT.SINGLE);
+		gd = new GridData(GridData.FILL_HORIZONTAL);
+		fileText.setLayoutData(gd);
+		fileText.addModifyListener(new ModifyListener() {
+			public void modifyText(ModifyEvent e) {
+				dialogChanged();
+			}
+		});
+		initialize();
+		dialogChanged();
+		setControl(container);
+	}
+
+	/**
+	 * Tests if the current workbench selection is a suitable container to use.
+	 */
+
+	private void initialize() {
+		if (selection != null && selection.isEmpty() == false
+				&& selection instanceof IStructuredSelection) {
+			IStructuredSelection ssel = (IStructuredSelection) selection;
+			if (ssel.size() > 1)
+				return;
+			Object obj = ssel.getFirstElement();
+			if (obj instanceof IResource) {
+				IContainer container;
+				if (obj instanceof IContainer)
+					container = (IContainer) obj;
+				else
+					container = ((IResource) obj).getParent();
+				containerText.setText(container.getFullPath().toString());
+			}
+		}
+		fileText.setText("new_file.json");
+	}
+
+	/**
+	 * Uses the standard container selection dialog to choose the new value for
+	 * the container field.
+	 */
+
+	private void handleBrowse() {
+		ContainerSelectionDialog dialog = new ContainerSelectionDialog(
+				getShell(), ResourcesPlugin.getWorkspace().getRoot(), false,
+				"Select new file container");
+		if (dialog.open() == ContainerSelectionDialog.OK) {
+			Object[] result = dialog.getResult();
+			if (result.length == 1) {
+				containerText.setText(((Path) result[0]).toString());
+			}
+		}
+	}
+
+	/**
+	 * Ensures that both text fields are set.
+	 */
+
+	private void dialogChanged() {
+		IResource container = ResourcesPlugin.getWorkspace().getRoot()
+				.findMember(new Path(getContainerName()));
+		String fileName = getFileName();
+
+		if (getContainerName().length() == 0) {
+			updateStatus("File container must be specified");
+			return;
+		}
+		if (container == null
+				|| (container.getType() & (IResource.PROJECT | IResource.FOLDER)) == 0) {
+			updateStatus("File container must exist");
+			return;
+		}
+		if (!container.isAccessible()) {
+			updateStatus("Project must be writable");
+			return;
+		}
+		if (fileName.length() == 0) {
+			updateStatus("File name must be specified");
+			return;
+		}
+		if (fileName.replace('\\', '/').indexOf('/', 1) > 0) {
+			updateStatus("File name must be valid");
+			return;
+		}
+		int dotLoc = fileName.lastIndexOf('.');
+		if (dotLoc != -1) {
+			String ext = fileName.substring(dotLoc + 1);
+			if (ext.equalsIgnoreCase("json") == false) {
+				updateStatus("File extension must be \"json\"");
+				return;
+			}
+		}
+		updateStatus(null);
+	}
+
+	private void updateStatus(String message) {
+		setErrorMessage(message);
+		setPageComplete(message == null);
+	}
+
+	public String getContainerName() {
+		return containerText.getText();
+	}
+
+	public String getFileName() {
+		return fileText.getText();
+	}
+}
\ No newline at end of file

OPTIMUS/eu.DECIDEh2020.optimus/src/org/eclipse/wb/swt/SWTResourceManager.java

+/*******************************************************************************
+ * Copyright (c) 2011 Google, Inc.
+ * 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
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Google, Inc. - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.wb.swt;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.Cursor;
+import org.eclipse.swt.graphics.Font;
+import org.eclipse.swt.graphics.FontData;
+import org.eclipse.swt.graphics.GC;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.graphics.ImageData;
+import org.eclipse.swt.graphics.RGB;
+import org.eclipse.swt.graphics.Rectangle;
+import org.eclipse.swt.widgets.Display;
+
+/**
+ * Utility class for managing OS resources associated with SWT controls such as colors, fonts, images, etc.
+ * <p>
+ * !!! IMPORTANT !!! Application code must explicitly invoke the <code>dispose()</code> method to release the
+ * operating system resources managed by cached objects when those objects and OS resources are no longer
+ * needed (e.g. on application shutdown)
+ * <p>
+ * This class may be freely distributed as part of any application or plugin.
+ * <p>
+ * @author scheglov_ke
+ * @author Dan Rubel
+ */
+public class SWTResourceManager {
+	////////////////////////////////////////////////////////////////////////////
+	//
+	// Color
+	//
+	////////////////////////////////////////////////////////////////////////////
+	private static Map<RGB, Color> m_colorMap = new HashMap<RGB, Color>();
+	/**
+	 * Returns the system {@link Color} matching the specific ID.
+	 * 
+	 * @param systemColorID
+	 *            the ID value for the color
+	 * @return the system {@link Color} matching the specific ID
+	 */
+	public static Color getColor(int systemColorID) {
+		Display display = Display.getCurrent();
+		return display.getSystemColor(systemColorID);
+	}
+	/**
+	 * Returns a {@link Color} given its red, green and blue component values.
+	 * 
+	 * @param r
+	 *            the red component of the color
+	 * @param g
+	 *            the green component of the color
+	 * @param b
+	 *            the blue component of the color
+	 * @return the {@link Color} matching the given red, green and blue component values
+	 */
+	public static Color getColor(int r, int g, int b) {
+		return getColor(new RGB(r, g, b));
+	}
+	/**
+	 * Returns a {@link Color} given its RGB value.
+	 * 
+	 * @param rgb
+	 *            the {@link RGB} value of the color
+	 * @return the {@link Color} matching the RGB value
+	 */
+	public static Color getColor(RGB rgb) {
+		Color color = m_colorMap.get(rgb);
+		if (color == null) {
+			Display display = Display.getCurrent();
+			color = new Color(display, rgb);
+			m_colorMap.put(rgb, color);
+		}
+		return color;
+	}
+	/**
+	 * Dispose of all the cached {@link Color}'s.
+	 */
+	public static void disposeColors() {
+		for (Color color : m_colorMap.values()) {
+			color.dispose();
+		}
+		m_colorMap.clear();
+	}
+	////////////////////////////////////////////////////////////////////////////
+	//
+	// Image
+	//
+	////////////////////////////////////////////////////////////////////////////
+	/**
+	 * Maps image paths to images.
+	 */
+	private static Map<String, Image> m_imageMap = new HashMap<String, Image>();
+	/**
+	 * Returns an {@link Image} encoded by the specified {@link InputStream}.
+	 * 
+	 * @param stream
+	 *            the {@link InputStream} encoding the image data
+	 * @return the {@link Image} encoded by the specified input stream
+	 */
+	protected static Image getImage(InputStream stream) throws IOException {
+		try {
+			Display display = Display.getCurrent();
+			ImageData data = new ImageData(stream);
+			if (data.transparentPixel > 0) {
+				return new Image(display, data, data.getTransparencyMask());
+			}
+			return new Image(display, data);
+		} finally {
+			stream.close();
+		}
+	}
+	/**
+	 * Returns an {@link Image} stored in the file at the specified path.
+	 * 
+	 * @param path
+	 *            the path to the image file
+	 * @return the {@link Image} stored in the file at the specified path
+	 */
+	public static Image getImage(String path) {
+		Image image = m_imageMap.get(path);
+		if (image == null) {
+			try {
+				image = getImage(new FileInputStream(path));
+				m_imageMap.put(path, image);
+			} catch (Exception e) {
+				image = getMissingImage();
+				m_imageMap.put(path, image);
+			}
+		}
+		return image;
+	}
+	/**
+	 * Returns an {@link Image} stored in the file at the specified path relative to the specified class.
+	 * 
+	 * @param clazz
+	 *            the {@link Class} relative to which to find the image
+	 * @param path
+	 *            the path to the image file, if starts with <code>'/'</code>
+	 * @return the {@link Image} stored in the file at the specified path
+	 */
+	public static Image getImage(Class<?> clazz, String path) {
+		String key = clazz.getName() + '|' + path;
+		Image image = m_imageMap.get(key);
+		if (image == null) {
+			try {
+				image = getImage(clazz.getResourceAsStream(path));
+				m_imageMap.put(key, image);
+			} catch (Exception e) {
+				image = getMissingImage();
+				m_imageMap.put(key, image);
+			}
+		}
+		return image;
+	}
+	private static final int MISSING_IMAGE_SIZE = 10;
+	/**
+	 * @return the small {@link Image} that can be used as placeholder for missing image.
+	 */
+	private static Image getMissingImage() {
+		Image image = new Image(Display.getCurrent(), MISSING_IMAGE_SIZE, MISSING_IMAGE_SIZE);
+		//
+		GC gc = new GC(image);
+		gc.setBackground(getColor(SWT.COLOR_RED));
+		gc.fillRectangle(0, 0, MISSING_IMAGE_SIZE, MISSING_IMAGE_SIZE);
+		gc.dispose();
+		//
+		return image;
+	}
+	/**
+	 * Style constant for placing decorator image in top left corner of base image.
+	 */
+	public static final int TOP_LEFT = 1;
+	/**
+	 * Style constant for placing decorator image in top right corner of base image.
+	 */
+	public static final int TOP_RIGHT = 2;
+	/**
+	 * Style constant for placing decorator image in bottom left corner of base image.
+	 */
+	public static final int BOTTOM_LEFT = 3;
+	/**
+	 * Style constant for placing decorator image in bottom right corner of base image.
+	 */
+	public static final int BOTTOM_RIGHT = 4;
+	/**
+	 * Internal value.
+	 */
+	protected static final int LAST_CORNER_KEY = 5;
+	/**
+	 * Maps images to decorated images.
+	 */
+	@SuppressWarnings("unchecked")
+	private static Map<Image, Map<Image, Image>>[] m_decoratedImageMap = new Map[LAST_CORNER_KEY];
+	/**
+	 * Returns an {@link Image} composed of a base image decorated by another image.
+	 * 
+	 * @param baseImage
+	 *            the base {@link Image} that should be decorated
+	 * @param decorator
+	 *            the {@link Image} to decorate the base image
+	 * @return {@link Image} The resulting decorated image
+	 */
+	public static Image decorateImage(Image baseImage, Image decorator) {
+		return decorateImage(baseImage, decorator, BOTTOM_RIGHT);
+	}
+	/**
+	 * Returns an {@link Image} composed of a base image decorated by another image.
+	 * 
+	 * @param baseImage
+	 *            the base {@link Image} that should be decorated
+	 * @param decorator
+	 *            the {@link Image} to decorate the base image
+	 * @param corner
+	 *            the corner to place decorator image
+	 * @return the resulting decorated {@link Image}
+	 */
+	public static Image decorateImage(final Image baseImage, final Image decorator, final int corner) {
+		if (corner <= 0 || corner >= LAST_CORNER_KEY) {
+			throw new IllegalArgumentException("Wrong decorate corner");
+		}
+		Map<Image, Map<Image, Image>> cornerDecoratedImageMap = m_decoratedImageMap[corner];
+		if (cornerDecoratedImageMap == null) {
+			cornerDecoratedImageMap = new HashMap<Image, Map<Image, Image>>();
+			m_decoratedImageMap[corner] = cornerDecoratedImageMap;
+		}
+		Map<Image, Image> decoratedMap = cornerDecoratedImageMap.get(baseImage);
+		if (decoratedMap == null) {
+			decoratedMap = new HashMap<Image, Image>();
+			cornerDecoratedImageMap.put(baseImage, decoratedMap);
+		}
+		//
+		Image result = decoratedMap.get(decorator);
+		if (result == null) {
+			Rectangle bib = baseImage.getBounds();
+			Rectangle dib = decorator.getBounds();
+			//
+			result = new Image(Display.getCurrent(), bib.width, bib.height);
+			//
+			GC gc = new GC(result);
+			gc.drawImage(baseImage, 0, 0);
+			if (corner == TOP_LEFT) {
+				gc.drawImage(decorator, 0, 0);
+			} else if (corner == TOP_RIGHT) {
+				gc.drawImage(decorator, bib.width - dib.width, 0);
+			} else if (corner == BOTTOM_LEFT) {
+				gc.drawImage(decorator, 0, bib.height - dib.height);
+			} else if (corner == BOTTOM_RIGHT) {
+				gc.drawImage(decorator, bib.width - dib.width, bib.height - dib.height);
+			}
+			gc.dispose();
+			//
+			decoratedMap.put(decorator, result);
+		}
+		return result;
+	}
+	/**
+	 * Dispose all of the cached {@link Image}'s.
+	 */
+	public static void disposeImages() {
+		// dispose loaded images
+		{
+			for (Image image : m_imageMap.values()) {
+				image.dispose();
+			}
+			m_imageMap.clear();
+		}
+		// dispose decorated images
+		for (int i = 0; i < m_decoratedImageMap.length; i++) {
+			Map<Image, Map<Image, Image>> cornerDecoratedImageMap = m_decoratedImageMap[i];
+			if (cornerDecoratedImageMap != null) {
+				for (Map<Image, Image> decoratedMap : cornerDecoratedImageMap.values()) {
+					for (Image image : decoratedMap.values()) {
+						image.dispose();
+					}
+					decoratedMap.clear();
+				}
+				cornerDecoratedImageMap.clear();
+			}
+		}
+	}
+	////////////////////////////////////////////////////////////////////////////
+	//
+	// Font
+	//
+	////////////////////////////////////////////////////////////////////////////
+	/**
+	 * Maps font names to fonts.
+	 */
+	private static Map<String, Font> m_fontMap = new HashMap<String, Font>();
+	/**
+	 * Maps fonts to their bold versions.
+	 */
+	private static Map<Font, Font> m_fontToBoldFontMap = new HashMap<Font, Font>();
+	/**
+	 * Returns a {@link Font} based on its name, height and style.
+	 * 
+	 * @param name
+	 *            the name of the font
+	 * @param height
+	 *            the height of the font
+	 * @param style
+	 *            the style of the font
+	 * @return {@link Font} The font matching the name, height and style
+	 */
+	public static Font getFont(String name, int height, int style) {
+		return getFont(name, height, style, false, false);
+	}
+	/**
+	 * Returns a {@link Font} based on its name, height and style. Windows-specific strikeout and underline
+	 * flags are also supported.
+	 * 
+	 * @param name
+	 *            the name of the font
+	 * @param size
+	 *            the size of the font
+	 * @param style
+	 *            the style of the font
+	 * @param strikeout
+	 *            the strikeout flag (warning: Windows only)
+	 * @param underline
+	 *            the underline flag (warning: Windows only)
+	 * @return {@link Font} The font matching the name, height, style, strikeout and underline
+	 */
+	public static Font getFont(String name, int size, int style, boolean strikeout, boolean underline) {
+		String fontName = name + '|' + size + '|' + style + '|' + strikeout + '|' + underline;
+		Font font = m_fontMap.get(fontName);
+		if (font == null) {
+			FontData fontData = new FontData(name, size, style);
+			if (strikeout || underline) {
+				try {
+					Class<?> logFontClass = Class.forName("org.eclipse.swt.internal.win32.LOGFONT"); //$NON-NLS-1$
+					Object logFont = FontData.class.getField("data").get(fontData); //$NON-NLS-1$
+					if (logFont != null && logFontClass != null) {
+						if (strikeout) {
+							logFontClass.getField("lfStrikeOut").set(logFont, Byte.valueOf((byte) 1)); //$NON-NLS-1$
+						}
+						if (underline) {
+							logFontClass.getField("lfUnderline").set(logFont, Byte.valueOf((byte) 1)); //$NON-NLS-1$
+						}
+					}
+				} catch (Throwable e) {
+					System.err.println("Unable to set underline or strikeout" + " (probably on a non-Windows platform). " + e); //$NON-NLS-1$ //$NON-NLS-2$
+				}
+			}
+			font = new Font(Display.getCurrent(), fontData);
+			m_fontMap.put(fontName, font);
+		}
+		return font;
+	}
+	/**
+	 * Returns a bold version of the given {@link Font}.
+	 * 
+	 * @param baseFont
+	 *            the {@link Font} for which a bold version is desired
+	 * @return the bold version of the given {@link Font}
+	 */
+	public static Font getBoldFont(Font baseFont) {
+		Font font = m_fontToBoldFontMap.get(baseFont);
+		if (font == null) {
+			FontData fontDatas[] = baseFont.getFontData();
+			FontData data = fontDatas[0];
+			font = new Font(Display.getCurrent(), data.getName(), data.getHeight(), SWT.BOLD);
+			m_fontToBoldFontMap.put(baseFont, font);
+		}
+		return font;
+	}
+	/**
+	 * Dispose all of the cached {@link Font}'s.
+	 */
+	public static void disposeFonts() {
+		// clear fonts
+		for (Font font : m_fontMap.values()) {
+			font.dispose();
+		}
+		m_fontMap.clear();
+		// clear bold fonts
+		for (Font font : m_fontToBoldFontMap.values()) {
+			font.dispose();
+		}
+		m_fontToBoldFontMap.clear();
+	}
+	////////////////////////////////////////////////////////////////////////////
+	//
+	// Cursor
+	//
+	////////////////////////////////////////////////////////////////////////////
+	/**
+	 * Maps IDs to cursors.
+	 */
+	private static Map<Integer, Cursor> m_idToCursorMap = new HashMap<Integer, Cursor>();
+	/**
+	 * Returns the system cursor matching the specific ID.
+	 * 
+	 * @param id
+	 *            int The ID value for the cursor
+	 * @return Cursor The system cursor matching the specific ID
+	 */
+	public static Cursor getCursor(int id) {
+		Integer key = Integer.valueOf(id);
+		Cursor cursor = m_idToCursorMap.get(key);
+		if (cursor == null) {
+			cursor = new Cursor(Display.getDefault(), id);
+			m_idToCursorMap.put(key, cursor);
+		}
+		return cursor;
+	}
+	/**
+	 * Dispose all of the cached cursors.
+	 */
+	public static void disposeCursors() {
+		for (Cursor cursor : m_idToCursorMap.values()) {
+			cursor.dispose();
+		}
+		m_idToCursorMap.clear();
+	}
+	////////////////////////////////////////////////////////////////////////////
+	//
+	// General
+	//
+	////////////////////////////////////////////////////////////////////////////
+	/**
+	 * Dispose of cached objects and their underlying OS resources. This should only be called when the cached
+	 * objects are no longer needed (e.g. on application shutdown).
+	 */
+	public static void dispose() {
+		disposeColors();
+		disposeImages();
+		disposeFonts();
+		disposeCursors();
+	}
+}
\ No newline at end of file