import java.util.HashMap;

    public static SymbolDefinitionSet createSymbolDefinitionSet(String name, HashMap<String, String> symbols) {

    	SymbolDefinitionSet definitionSet = new SymbolDefinitionSet(name);

        definitionSet.define(name);

        for (Iterator<String> iterator = symbols.keySet().iterator(); iterator.hasNext();) {

            String key = iterator.next();

            try {

                String value = symbols.get(key);

                definitionSet.define(key, value);

            } 

            catch (RuntimeException e) {

                MTJCorePlugin.log(IStatus.ERROR, e);

            }

        }

        return definitionSet;

    }

import java.util.Properties;

        Properties properties = persistenceProvider.loadProperties(KEYS_KEY);

        if(properties != null) {

	        Iterator<?> iterator = properties.keySet().iterator();

	        while(iterator.hasNext()) {

	        	String key = (String) iterator.next();

	        	String value = properties.getProperty(key);

	        	map.put(key, value);

	        }

        }

        Properties properties = new Properties();

import org.eclipse.jface.window.Window;

import org.eclipse.jface.wizard.WizardDialog;

import org.eclipse.mtj.core.model.device.DeviceRegistry;

import org.eclipse.mtj.core.model.device.IDevice;

    private Button importSetButton;

     * The import set button has been selected.

     */

    private void handleImportSetButton() {

    	SymbolDefinitionsImportWizard wizard = new SymbolDefinitionsImportWizard();

        WizardDialog dialog = new WizardDialog(this.getShell(), wizard);

        if(dialog.open() == Window.OK) {

        	definitionsComboViewer.refresh();

        }

        //try {

    	//}

    	//catch(PersistenceException e) {

    	//	handleException("Error import definition set", e);

    	//}

    }

    /**

        importSetButton = new Button(nameButtonComposite, SWT.PUSH);

        importSetButton.setText("Import");

        importSetButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

        importSetButton.addSelectionListener(new SelectionAdapter() {

            @Override

            public void widgetSelected(SelectionEvent e) {

                handleImportSetButton();

            }

        });

package org.eclipse.mtj.ui.internal.preferences;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.lang.reflect.InvocationTargetException;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.HashMap;

import java.util.Iterator;

import java.util.StringTokenizer;

import java.util.Vector;

import java.util.jar.JarEntry;

import java.util.jar.JarFile;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.wizard.IWizardContainer;

import org.eclipse.jface.wizard.Wizard;

import org.eclipse.mtj.core.IMTJCoreConstants;

import org.eclipse.mtj.core.internal.MTJCorePlugin;

import org.eclipse.mtj.core.model.device.DeviceFactory;

import org.eclipse.mtj.core.model.device.preprocess.DeviceSymbolDefinitionSetFactory;

import org.eclipse.mtj.core.model.preprocessor.SymbolDefinitionSet;

import org.eclipse.mtj.core.model.preprocessor.SymbolDefinitionSetRegistry;

import org.eclipse.mtj.ui.internal.MTJUIPlugin;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.progress.IProgressService;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

import org.xml.sax.SAXException;

public class SymbolDefinitionsImportWizard extends Wizard {

	private static final String J2MEPOLISH_CAPABILITY_SEPARATOR = ",";

	private SymbolDefinitionsImportWizardPage wizardPage;

	private String importDirectory = null;

	public SymbolDefinitionsImportWizard() {

		super();

        setNeedsProgressMonitor(true);

        setWindowTitle("Import Devices");

    }

	@Override

	public boolean performFinish() {

		IProgressService progressService = PlatformUI.getWorkbench().getProgressService();

		switch(wizardPage.getImportType()) {

			case SymbolDefinitionsImportWizardPage.IMPORT_FROM_ANTENNA_JAR:

				try {

					progressService.run(true, true, getProcessImportFromAntennaJarFile());

				} 

				catch (InvocationTargetException e) {

					e.printStackTrace();

				} 

				catch (InterruptedException e) {

					e.printStackTrace();

				}

				break;

			case SymbolDefinitionsImportWizardPage.IMPORT_J2MEPOLISH_FORMAT:

				importDirectory = wizardPage.getDirectory();

				try {

					progressService.run(true, true, getProcessImportFromXMLFiles());

				} 

				catch (InvocationTargetException e) {

					e.printStackTrace();

				} 

				catch (InterruptedException e) {

					e.printStackTrace();

				}

				break;

			case SymbolDefinitionsImportWizardPage.IMPORT_MTJ_FORMAT:

				break;

		}

		return true;

	}

	@Override

	public void addPages() {

		 wizardPage = new SymbolDefinitionsImportWizardPage();

	     addPage(wizardPage);

	}

	private IRunnableWithProgress getProcessImportFromAntennaJarFile() {

		// The runnable to do import definitions

		return new IRunnableWithProgress() {

			public void run(IProgressMonitor monitor) {

				JarFile antennaFileJar = null;

				try {

					IPreferenceStore preferenceStore = MTJUIPlugin.getDefault().getCorePreferenceStore();

					String antennaFile = preferenceStore.getString(IMTJCoreConstants.PREF_ANTENNA_JAR);

					// search devices.xml & groups.xml from Antenna Jar file

					InputStream devicesInputStream = null;

					InputStream groupsInputStream = null;

					antennaFileJar = new JarFile(new File(antennaFile));

					Enumeration<JarEntry> e = antennaFileJar.entries();

					while(e.hasMoreElements()) {

						JarEntry entry = e.nextElement();

						if(entry.getName().toLowerCase().equals("devices.xml")) {

							devicesInputStream = antennaFileJar.getInputStream(entry);

						}

						if(entry.getName().toLowerCase().equals("groups.xml")) {

							groupsInputStream = antennaFileJar.getInputStream(entry);

						}

					}

					if(devicesInputStream != null && groupsInputStream != null) {

						try {

							importFromJ2MEPolishFormat(devicesInputStream, groupsInputStream);

						}

						catch(Exception ex) {

							ex.printStackTrace();

						}

					}

				} 

				catch (IOException e) {

					e.printStackTrace();

				}

				finally {

					try {

						antennaFileJar.close();

					}

					catch(Exception e) {

					}

				}

		    }

		};

	}

	private IRunnableWithProgress getProcessImportFromXMLFiles() {

		// The runnable to do import definitions

		return new IRunnableWithProgress() {

			public void run(IProgressMonitor monitor) {

				InputStream devicesInputStream = null;

				InputStream groupsInputStream = null;

				try {

					// search devices.xml & groups.xml from Antenna Jar file

					devicesInputStream = new FileInputStream(new File(importDirectory + File.separator + "devices.xml"));

					groupsInputStream = new FileInputStream(new File(importDirectory + File.separator + "groups.xml"));

					if(devicesInputStream != null && groupsInputStream != null) {

						try {

							importFromJ2MEPolishFormat(devicesInputStream, groupsInputStream);

						}

						catch(Exception ex) {

							ex.printStackTrace();

						}

					}

				} 

				catch (IOException e) {

					e.printStackTrace();

				}

				finally {

					try {

						devicesInputStream.close();

					}

					catch(Exception e) {

					}

					try {

						groupsInputStream.close();

					}

					catch(Exception e) {

					}

				}

		    }

		};

	}

	/*

	 * Functions for importFromJ2MEPolishFormat:

	 *  	- importFromJ2MEPolishFormat

	 *  	- prepareGroups

	 *  	- getGroupCapabilities

	 *      - copyCapabilities

	 *      - copyCapability

	 *      - mergeCapabilities

	 */

	private void importFromJ2MEPolishFormat(InputStream devicesInputStream, InputStream groupsInputStream) {

		try {

			DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

			DocumentBuilder db = dbf.newDocumentBuilder();

			Document devicesDOM = db.parse(devicesInputStream);

			Document groupsDOM = db.parse(groupsInputStream);

			HashMap<String, Element> groups = prepareGroups(groupsDOM);

			NodeList nl = devicesDOM.getElementsByTagName("device");

			for(int i = 0; i < nl.getLength(); i++) {

				HashMap<String, String> capabilities = new HashMap<String, String>();

				HashMap<String, String> groupCapabilities;

				String features;

				Element deviceElement = (Element) nl.item(i);

				String name = ((Element) deviceElement.getElementsByTagName("identifier").item(0)).getTextContent();

				Element featuresElement = (Element) deviceElement.getElementsByTagName("features").item(0);

				if(featuresElement != null) {

					features = featuresElement.getTextContent();

					capabilities.put("features", features);

				}

				Element groupElement = (Element) deviceElement.getElementsByTagName("groups").item(0);

				if(groupElement != null) {

					StringTokenizer st = new StringTokenizer(groupElement.getTextContent(), J2MEPOLISH_CAPABILITY_SEPARATOR);

					while(st.hasMoreTokens()) {

						String group = st.nextToken().trim();

						groupCapabilities = getGroupCapabilities(groups, group);

						copyCapabilities(capabilities, groupCapabilities);

					}

					capabilities.put("groups", groupElement.getTextContent().toLowerCase());

				}

				NodeList capabilitiesNL = deviceElement.getElementsByTagName("capability");

				for(int j = 0; j < capabilitiesNL.getLength(); j++) {

					Element capabilityElement = (Element) capabilitiesNL.item(j);

					copyCapability(capabilities, capabilityElement.getAttribute("name"), capabilityElement.getAttribute("value"));

				}

				capabilities.put(name, "true");

				StringTokenizer st = new StringTokenizer(name, J2MEPOLISH_CAPABILITY_SEPARATOR);

				while(st.hasMoreTokens()) {

					String device = st.nextToken().trim();

					device = device.replace('/', '_');

					device = device.replace('(', '_');

					device = device.replace(')', '_');

					SymbolDefinitionSet definitionSet = DeviceSymbolDefinitionSetFactory.createSymbolDefinitionSet(device, capabilities);

					SymbolDefinitionSetRegistry.singleton.addDefinitionSet(definitionSet);

				}

			}

			SymbolDefinitionSetRegistry.singleton.store();

		}

		catch(Exception e) {

			MTJCorePlugin.log(IStatus.ERROR, e);

		}

	}

	private HashMap<String, Element> prepareGroups(Document groupsDOM) {

		HashMap<String, Element> result = new HashMap<String, Element>();

		NodeList nl = groupsDOM.getElementsByTagName("group");

		for(int i = 0; i < nl.getLength(); i++) {

			Element groupElement = (Element) nl.item(i);

			String name = ((Element) groupElement.getElementsByTagName("name").item(0)).getTextContent();

			result.put(name, groupElement);

		}

		return result;

	}

	private HashMap<String, String> getGroupCapabilities(HashMap<String, Element> groups, String name) {

		Element groupElement = groups.get(name);

		HashMap<String, String> result = new HashMap<String, String>();

		NodeList nl = groupElement.getElementsByTagName("parent");

		if(nl != null && nl.getLength() > 0) {

			Element parent = (Element) nl.item(0);

			String parentValue = parent.getTextContent(); 

			if(parentValue != null && !parent.getTextContent().equals("")) {

				HashMap<String, String> parentCapabilities = getGroupCapabilities(groups, parent.getTextContent());

				copyCapabilities(result, parentCapabilities);

			}

		}

		nl = groupElement.getElementsByTagName("capability");

		for(int i = 0; i < nl.getLength(); i++) {

			Element capabilityElement = (Element) nl.item(i);

			result.put(capabilityElement.getAttribute("name"), capabilityElement.getAttribute("value"));

		}

		return result;

	}

	private void copyCapabilities(HashMap<String, String> capabilities, HashMap<String, String> parentCapabilities) {

		Iterator<String> i = parentCapabilities.keySet().iterator();

		while(i.hasNext()) {

			String capability = i.next();

			copyCapability(capabilities, capability, parentCapabilities.get(capability));

		}

	}

	private void copyCapability(HashMap<String, String> capabilities, String name, String capability) {

		String currentCapabilityValue = capabilities.get(name);

		if(currentCapabilityValue == null || currentCapabilityValue.equals("")) {

			capabilities.put(name, capability);

		}

		else {

			String mergedCapabilities = mergeCapabilities(currentCapabilityValue, capability);

			capabilities.put(name, mergedCapabilities);

		}

	}

	private String mergeCapabilities(String currentCapability, String newCapability) {

		Vector<String> v = new Vector<String>();

		StringTokenizer st = new StringTokenizer(currentCapability, J2MEPOLISH_CAPABILITY_SEPARATOR);

		while(st.hasMoreTokens()) {

			v.add(st.nextToken().trim());

		}

		st = new StringTokenizer(newCapability, J2MEPOLISH_CAPABILITY_SEPARATOR);

		while(st.hasMoreTokens()) {

			String capability = st.nextToken().trim();

			if(v.indexOf(capability) == -1) {

				v.add(capability);

			}

		}

		String result = "";

		for(int i = 0; i < v.size(); i++) {

			if(i > 0) {

				result = result.concat(",");

			}

			result = result.concat(v.elementAt(i));

		}

		return result;

	}

}

package org.eclipse.mtj.ui.internal.preferences;

import java.io.File;

import javax.sql.rowset.Predicate;

import org.eclipse.jface.dialogs.IDialogSettings;

import org.eclipse.jface.preference.FieldEditor;

import org.eclipse.jface.preference.FileFieldEditor;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.wizard.WizardPage;

import org.eclipse.mtj.core.IMTJCoreConstants;

import org.eclipse.mtj.ui.internal.MTJUIPlugin;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.ControlAdapter;

import org.eclipse.swt.events.ControlEvent;

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.graphics.Point;

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.DirectoryDialog;

import org.eclipse.swt.widgets.FileDialog;

import org.eclipse.swt.widgets.Group;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Text;

public class SymbolDefinitionsImportWizardPage extends WizardPage {

	public static final int IMPORT_FROM_ANTENNA_JAR  = 0;

	public static final int IMPORT_J2MEPOLISH_FORMAT = 1;

	public static final int IMPORT_MTJ_FORMAT        = 2;

	private static final String[] BUTTON_TEXTS = new String[] {

    	"Import from Antenna.jar library", 

    	"Import from XML files (devices.xml, groups.xml)",

	};

	public static final String NAME = "symbolDefinitionsImportPage";

	private static final String KEY_WIDTH =  "dialogWidth";

	private static final String KEY_HEIGHT = "dialogHeight";

	private Button[] importTypeRadios;

	private Label importFileLabel;

	private Text importDirectory;

	private Button importFileBrowseButton;

	private String antennaFile;

	public SymbolDefinitionsImportWizardPage() {

		super(NAME, "Import Symbol Definitions", null);

		setPageComplete(true);

	}

	@Override

	public void createControl(Composite parent) {

		parent.setLayoutData(new GridData(GridData.FILL_BOTH));

		final Composite composite = new Composite(parent, SWT.NONE);

		composite.setLayout(new GridLayout(1, false));

		composite.setLayoutData(new GridData(GridData.FILL_BOTH));

		composite.addControlListener(new ControlAdapter() {

			@Override

			public void controlResized(ControlEvent e) {

				storeSize();

			}

		});

		setControl(composite);

		IPreferenceStore preferenceStore = MTJUIPlugin.getDefault().getCorePreferenceStore();

		antennaFile = preferenceStore.getString(IMTJCoreConstants.PREF_ANTENNA_JAR);

		addImportSelectorControls(composite);

		// Set the size if previously stored away

		Point size = retrieveSize();

		if (size != null) {

			composite.setSize(size);

		}

	}

	/**

	 * Add the controls that allow the user to select the type of import.

	 * 

	 * @param parent

	 */

	private void addImportSelectorControls(Composite parent) {

		Group importTypeGroup = new Group(parent, SWT.NONE);

		importTypeGroup.setText(" From ");

		importTypeGroup.setLayout(new GridLayout(1, false));

		importTypeGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

		importTypeRadios = new Button[BUTTON_TEXTS.length];

		for (int i = 0; i < BUTTON_TEXTS.length; i++) {

			importTypeRadios[i] = new Button(importTypeGroup, SWT.RADIO);

			importTypeRadios[i].setText(BUTTON_TEXTS[i]);

	    }

		// set default selection

		importTypeRadios[0].setSelection(true);

		importTypeRadios[1].addSelectionListener(new SelectionAdapter() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				if(((Button) e.getSource()).getSelection()) {

					updateControlEnable(true);

				}

				else {

					updateControlEnable(false);

				}

				updateFinishButton();

			}

		});

		addChooseFileControl(importTypeGroup);

		updateControlEnable(false);

		updateFinishButton();

	}

	private void addChooseFileControl(Composite parent) {

		Composite composite = new Composite(parent, SWT.NONE);

		composite.setLayout(new GridLayout(3, false));

		composite.setLayoutData(new GridData(GridData.FILL_BOTH));

		importFileLabel = new Label(composite, SWT.NONE);

		importFileLabel.setText("Specify directory:");

		importDirectory = new Text(composite, SWT.BORDER);

		importDirectory.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));

		importDirectory.addModifyListener(new ModifyListener() {

			public void modifyText(ModifyEvent e) {

				updateFinishButton();

			}

		});

		importFileBrowseButton = new Button(composite, SWT.PUSH);

		importFileBrowseButton.setText("Browse...");

		importFileBrowseButton.addSelectionListener(new SelectionAdapter() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				handleBrowseButton();

			}

		});

	}

	public String getDirectory() {

		return importDirectory.getText();

	}

	/**

	 * Store off the size of the control in the dialog settings.

	 */

	private void storeSize() {

		IDialogSettings settings = getDialogSettings();

		Point size = getControl().getSize();

		if(settings != null) {

			settings.put(KEY_WIDTH, size.x);

			settings.put(KEY_HEIGHT, size.y);

		}

	}

	/**

	 * Retrieve the previously stored size or <code>null</code> if not found.

	 * 

	 * @return

	 */

	private Point retrieveSize() {

		Point size = null;

		IDialogSettings settings = getDialogSettings();

		if(settings != null && settings.get(KEY_WIDTH) != null) {

			size = new Point(settings.getInt(KEY_WIDTH), settings.getInt(KEY_HEIGHT));

		}

		return size;

	}

	private void handleBrowseButton() {

		DirectoryDialog dialog = new DirectoryDialog(getShell());

		String directory = dialog.open();

		if (directory != null) {

			importDirectory.setText(directory);

			updateFinishButton();

		}

	}

	private void updateControlEnable(boolean value) {

		importFileLabel.setEnabled(value);

		importFileBrowseButton.setEnabled(value);

		importDirectory.setEnabled(value);

	}

	public void updateFinishButton() {

		if(importTypeRadios[0].getSelection()) {

			if(!new File(antennaFile).exists()) {

				setPageComplete(false);

				setErrorMessage("error2");

				setErrorMessage("Antenna.jar library is not specified.");

				return;

			}

		}

		else if(importTypeRadios[1].getSelection()) {

			String directory = importDirectory.getText().trim();

			if(!new File(directory + File.separator + "devices.xml").exists() ||

			   !new File(directory + File.separator + "groups.xml").exists()) {

				setPageComplete(false);

				setErrorMessage("Directory doesn't contain files devices.xml and groups.xml.");

				return;

			}

		}

		setErrorMessage(null);

		setPageComplete(true);

	}

	public int getImportType() {

		if(importTypeRadios[0].getSelection()) {

			return IMPORT_FROM_ANTENNA_JAR;

		}

		else if(importTypeRadios[1].getSelection()) {

			return IMPORT_J2MEPOLISH_FORMAT;

		}

		return IMPORT_MTJ_FORMAT;

	}

}