toxtree 0.0.1

data/Toxtree-v2.6.13/src/toxTree/data/MoleculesIterator.java

@@ -0,0 +1,439 @@
+/*
+Copyright Ideaconsult Ltd. (C) 2005-2007 
+
+Contact: nina@acad.bg
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+All we ask is that proper credit is given for our work, which includes
+- but is not limited to - adding the above copyright notice to the beginning
+of your source code files, and to any copyright notice that you may distribute
+with programs based on this work.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+*/
+package toxTree.data;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.vecmath.Point2d;
+import javax.vecmath.Vector2d;
+
+import org.openscience.cdk.DefaultChemObjectBuilder;
+import org.openscience.cdk.MoleculeSet;
+import org.openscience.cdk.exception.CDKException;
+import org.openscience.cdk.graph.ConnectivityChecker;
+import org.openscience.cdk.interfaces.IAtom;
+import org.openscience.cdk.interfaces.IAtomContainer;
+import org.openscience.cdk.interfaces.IChemFile;
+import org.openscience.cdk.interfaces.IChemObjectBuilder;
+import org.openscience.cdk.interfaces.IMolecule;
+import org.openscience.cdk.interfaces.IMoleculeSet;
+import org.openscience.cdk.interfaces.IPseudoAtom;
+import org.openscience.cdk.io.DefaultChemObjectWriter;
+import org.openscience.cdk.io.ISimpleChemObjectReader;
+import org.openscience.cdk.io.MDLV2000Reader;
+import org.openscience.cdk.io.SMILESReader;
+import org.openscience.cdk.layout.StructureDiagramGenerator;
+import org.openscience.cdk.silent.SilentChemObjectBuilder;
+import org.openscience.cdk.smiles.FixBondOrdersTool;
+import org.openscience.cdk.templates.MoleculeFactory;
+import org.openscience.cdk.tools.CDKHydrogenAdder;
+import org.openscience.cdk.tools.manipulator.AtomContainerManipulator;
+import org.openscience.cdk.tools.manipulator.ChemFileManipulator;
+
+import toxTree.core.IMoleculesIterator;
+import toxTree.exceptions.ToxTreeIOException;
+import toxTree.io.PDFWriter;
+import ambit2.core.config.AmbitCONSTANTS;
+import ambit2.core.data.MoleculeTools;
+import ambit2.core.io.DelimitedFileFormat;
+import ambit2.core.io.DelimitedFileReader;
+import ambit2.core.io.DelimitedFileWriter;
+import ambit2.core.io.MDLWriter;
+import ambit2.core.io.MyIteratingMDLReader;
+import ambit2.core.io.ReaderFactoryExtended;
+
+
+/**
+ * Contains molecules <ul>
+ * <li>loaded from a file, 
+ * <li>entered by SMILES {@link toxtree.ui.molecule.SmilesEntryPanel}  
+ * <li>entered by structure diagram editor {@link toxTree.ui.molecule.JChemPaintDialog}
+ * </ul>
+ * @author Nina Jeliazkova
+ * <b>Modified</b> 2005-9-3
+ */
+public class MoleculesIterator implements IMoleculesIterator {
+	
+	private static transient StructureDiagramGenerator sdg = null;
+	protected ListOfAtomContainers containers = null;
+	protected int currentNo = 0;	
+	protected transient static Logger logger  = Logger.getLogger(MoleculesIterator.class.getName());
+    protected int status = 0; //0-OK 1-reading  2-writing 
+    protected String filename = "";
+	/**
+	 * Comment for <code>serialVersionUID</code>
+	 */
+	private static final long serialVersionUID = 8781174694308416291L;
+
+	/**
+	 * 
+	 */
+	public MoleculesIterator() {
+		super();
+		containers = new ListOfAtomContainers();
+		
+        IMolecule molecule = MoleculeFactory.makeAlkane(6);
+        molecule.setProperty(AmbitCONSTANTS.NAMES,"Created from SMILES");
+        molecule.setProperty(AmbitCONSTANTS.SMILES,"CCCCCC");
+        containers.addAtomContainer(molecule);
+        currentNo = 0;        
+	}
+
+	/* (non-Javadoc)
+	 * @see java.util.Iterator#remove()
+	 */
+	public void remove() {
+
+	}
+	public IAtomContainer getAtomContainer(int index) {
+		return getContainers().getAtomContainer(index);
+	}
+	/* (non-Javadoc)
+	 * @see java.util.Iterator#hasNext()
+	 */
+	public boolean hasNext() {
+		if (getContainers() == null) return false;
+		return ((currentNo+1) < getContainers().getAtomContainerCount());
+	}
+
+	/* (non-Javadoc)
+	 * @see java.util.Iterator#next()
+	 */
+	public Object next() {
+        if (getContainers() == null)	return setCurrentNo(0);
+        else  return setCurrentNo(currentNo+1); 
+	}
+
+	
+	/**
+	 * @return Returns the molecules.
+	 */
+	public IAtomContainer[] getMolecules() {
+		return getContainers().getAtomContainers();
+	}
+	/**
+	 * @param molecules The molecules to set.
+	 */
+	public void setMolecules(List molecules) {
+		containers.clear();
+		for (int i=0; i < molecules.size(); i++ )
+			if (molecules.get(i) instanceof IAtomContainer)
+			containers.add((IAtomContainer)molecules.get(i));
+		currentNo = 0;
+	}
+	/**
+	 * @return Returns the currentNo.
+	 */
+	public int getCurrentNo() {
+		return currentNo;
+	}
+	public void clear() {
+		currentNo = -1;
+		containers.clear();
+		filename = "";
+	}
+    public Object prev() {
+        if (getContainers() == null)	return setCurrentNo(0);
+        else  return setCurrentNo(currentNo-1); 
+    }   
+	
+    public Object first() {
+        if (getContainers() == null)	return setCurrentNo(0);
+        else  return setCurrentNo(0); 
+    }
+    public Object last() {
+        if (getContainers() == null)	return setCurrentNo(0);
+        else  return setCurrentNo(containers.size()-1); 
+    }   	
+    public IAtomContainer setCurrentNo(int record) {
+        if (getContainers() == null) currentNo = 0;
+        else { 
+        	currentNo = record;
+        	if (currentNo < 0) currentNo = 0;
+        	else if (currentNo >= getMoleculesCount())
+        		currentNo = getMoleculesCount()-1;
+        }
+        return getMolecule();
+    }
+	/**
+	 * @return Returns the molecule.
+	 */
+	public IAtomContainer getMolecule() {
+		if ((currentNo >= 0) && (currentNo < containers.size()))
+			return getContainers().getAtomContainer(currentNo);
+		else 
+			return null;
+	}
+	public int getMoleculesCount() {
+		return getContainers().getAtomContainerCount();
+	}
+	public void addMolecule(IAtomContainer mol) {
+		if (getContainers() == containers) {
+			containers.addAtomContainer(mol);
+			last();
+		}
+	}
+	public void setMolecule(IAtomContainer mol) {
+		if (getContainers() == containers) {
+			containers.set(currentNo,mol);
+		}
+	}
+    protected void useIterativeReader(InputStream in) {
+        containers.clear();
+        FixBondOrdersTool fbt = new FixBondOrdersTool();
+        IChemObjectBuilder builder = SilentChemObjectBuilder.getInstance();
+        MyIteratingMDLReader reader = new MyIteratingMDLReader(in, builder);
+        int r = 0;
+        CDKHydrogenAdder hadder = CDKHydrogenAdder.getInstance(builder);
+        while (reader.hasNext()) {
+            Object o = reader.next();
+            if (o instanceof IAtomContainer) {
+            	IAtomContainer mol = (IAtomContainer)o;
+            	try {
+            		AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(mol);
+           	       for (IAtom atom : mol.atoms()) 
+            	            if ( !(atom instanceof IPseudoAtom) && (atom.getAtomTypeName() != null)) 
+            	               hadder.addImplicitHydrogens(mol, atom);
+               	   //mol = fbt.kekuliseAromaticRings((IMolecule)mol);
+           	       //CDKHueckelAromaticityDetector.detectAromaticity(mol);
+            	} catch (Exception x) {
+            		x.printStackTrace();
+            	}
+            	
+            	containers.add(mol);
+                
+                r++;
+            }    
+        }
+        currentNo = 0;
+    }
+    public List openFile(File input) throws ToxTreeIOException {
+        ReaderFactoryExtended factory = new ReaderFactoryExtended();
+        filename = input.getAbsolutePath();
+        try {
+        if (!input.isDirectory()) {
+        	ISimpleChemObjectReader reader=null;
+        	logger.fine("Trying to read\t"+input);
+        	String fe = input.toString().toLowerCase(); 
+            if (fe.endsWith(".csv")) {  
+      	      reader = new DelimitedFileReader(new FileReader(input));
+              logger.fine("Expecting SMILES format...");
+            } else if (fe.endsWith(".txt")) {  
+      	      reader = new DelimitedFileReader(new FileReader(input),new DelimitedFileFormat("\t ",'"'));
+              logger.fine("Expecting TXT format...");              
+            } else if (fe.endsWith(".smi")) {  
+        	      reader = new SMILESReader(new FileReader(input));
+                logger.fine("Expecting SMILES format...");
+            } else if (fe.endsWith(".sdf")) {  
+                
+              //reader = new MDLReader(new FileReader(input));
+              logger.fine("Expecting SDF format...");
+              useIterativeReader(new FileInputStream(input));
+              return null;
+            } else if (fe.endsWith(".mol")) {  
+                
+                //reader = new MDLReader(new FileReader(input));
+                logger.fine("Expecting MOL format...");
+                reader = new MDLV2000Reader(new FileReader(input));
+            
+          } else
+            	reader = factory.createReader(new FileReader(input));
+            
+            if (reader != null) {
+                try {
+                	IChemFile content = (IChemFile)reader.read(MoleculeTools.newChemFile(SilentChemObjectBuilder.getInstance()));
+	                //SetOfMolecules content = (SetOfMolecules) reader.read(new SetOfMolecules());
+	                reader.close();
+	                if (content == null) {
+	                	throw new ToxTreeIOException(MSG_EMPTYFILE,filename);
+	                }
+	                // apply modifications
+//	                AtomContainer[] c = content.getAtomContainers();
+	                List c = ChemFileManipulator.getAllAtomContainers(content);
+	                if (c.size() <= 0) {
+	                	throw new ToxTreeIOException(MSG_EMPTYFILE,filename);
+	                } if ((c.size() == 1) && (fe.endsWith(".mol")) && (c.get(0) != null)) {
+	                	((IAtomContainer)c.get(0)).setProperty(AmbitCONSTANTS.NAMES,filename);
+	                }
+	                if (!(c.get(0) instanceof IAtomContainer)) {
+	                	throw new ToxTreeIOException(MSG_EMPTYFILE + " found " + c.get(0).getClass().getName(),filename);
+	                }
+	                logger.fine(MSG_OPENSUCCESS+filename+"\tMolecules read from file\t"+c.size());
+	                return c;
+                } catch (CDKException x) {
+                	throw new ToxTreeIOException(MSG_ERRORONOPEN,x,filename);
+                } catch (Exception x) {
+                	throw new ToxTreeIOException(MSG_ERRORONOPEN,x,filename);
+                }
+            } else {
+            	throw new ToxTreeIOException(MSG_UNSUPPORTEDFORMAT,filename);
+            }
+        } else throw new ToxTreeIOException("Input is a directory!",filename);
+        } catch (IOException x) {
+        	throw new ToxTreeIOException(MSG_ERRORONOPEN,x,filename);
+        } catch (Exception x) {
+        	throw new ToxTreeIOException(MSG_ERRORONOPEN,x,filename);
+        }
+    }
+    public void saveFile(File output) throws ToxTreeIOException {
+    	DefaultChemObjectWriter writer = null;
+    	String filename = "";
+    	MDLWriter mdlWriter = null;
+    	try {
+    		filename = output.toString();
+	    	if (filename.toLowerCase().endsWith(".sdf")) { 
+	    		mdlWriter = new MDLWriter(new FileWriter(output));
+	    		mdlWriter.dontWriteAromatic();
+	    		writer = mdlWriter;
+	    	} else	if (filename.toLowerCase().endsWith(".csv")) { 
+		    	writer = new DelimitedFileWriter(new FileWriter(output));
+		    	mdlWriter = null;
+	    	} else	if (filename.toLowerCase().endsWith(".txt")) { 
+		    	writer = new DelimitedFileWriter(new FileWriter(output),new DelimitedFileFormat("\t " ,'"'));
+		    	mdlWriter = null;
+            } else  if (filename.toLowerCase().endsWith(".pdf")) { 
+                writer = new PDFWriter(new FileOutputStream(output));
+                mdlWriter = null;
+            }
+	    	if (writer != null) {
+	    		 
+	    		//first(); 
+	    		int c =0;
+	    		for (int record =0; record < getContainers().getAtomContainerCount(); record++) {
+	    			IAtomContainer ac = getContainers().getAtomContainer(record);
+	    			if (ac !=null) {
+	    				c++;
+	    				logger.finer("Writing compound \t"+Integer.toString(record));
+	    				if (mdlWriter != null) {
+	    					mdlWriter.setSdFields(ac.getProperties());
+	    				}
+	    				try {
+	    					writer.write(ac);
+	    				} catch (Exception x) {
+	    					logger.log(Level.SEVERE,ac.toString(),x);
+	    				}
+	    			}
+	    		}
+				writer.close();
+				logger.fine(MSG_SAVESUCCESS+filename+"\tCompounds written\t"+Integer.toString(c));
+	    	} else {
+	    		throw new ToxTreeIOException(MSG_UNSUPPORTEDFORMAT,filename);
+	    	}
+    	} catch (CDKException x) {
+
+    		throw new ToxTreeIOException(MSG_ERRORONSAVE,x,filename);    		
+    	} catch (IOException x) {
+    		throw new ToxTreeIOException(MSG_ERRORONSAVE,x,filename);    		    		
+    	
+		} catch (Exception x) {
+			throw new ToxTreeIOException(MSG_ERRORONSAVE,x,filename);    					
+		}
+    }
+	public boolean isReading() {
+		return status == 1;
+	}
+	public boolean isWriting() {
+		return status == 2;
+	}	
+	public String getStatus() {
+		switch (status) {
+		case 0: return "Compound(s) loaded\t" + getMoleculesCount();
+		case 1: return "Reading file ...";
+		case 2: return "Writing file ...";
+		default: return "Unknown";
+		}
+	}
+	public void setReading() {
+		status = 1;
+	}
+	public void setWriting() {
+		status = 2;
+	}
+	public void setDone(boolean success) {
+		status = 0;
+		
+		if (!success) {
+			if (containers.getAtomContainerCount() == 0)
+				filename = "";
+		}
+	}
+	
+	@Override
+	public String toString() {
+		return filename;
+	}
+	public IMoleculeSet getSetOfAtomContainers() {
+		IMoleculeSet c = new MoleculeSet();
+		for (int i=0; i< getContainers().getAtomContainerCount();i++)
+			c.addAtomContainer(getContainers().getAtomContainer(i));
+		return c;
+	}
+	public IMoleculeSet getMoleculeForEdit() throws Exception {
+		IChemObjectBuilder builder4jcp = DefaultChemObjectBuilder.getInstance(); //JCP still works with default builders
+		sdg = null;
+		sdg = new StructureDiagramGenerator();
+		IMoleculeSet m = null;
+		//JCP crashes if empty molecule is submitted, so let's give it single C atom
+		if ((getMolecule()==null) || (getMolecule().getAtomCount()==0)) {
+			IMolecule mol = MoleculeTools.newMolecule(builder4jcp);
+			IAtom a = MoleculeTools.newAtom(builder4jcp,"C");
+			a.setPoint2d(new Point2d(0,0));
+			mol.addAtom(a);
+			m = MoleculeTools.newMoleculeSet(builder4jcp);
+			m.addMolecule(mol);
+		} else {
+			m = ConnectivityChecker.partitionIntoMolecules(getMolecule());
+			//IMoleculeSet m =  new MoleculeSet();
+			for (int i=0; i< m.getMoleculeCount();i++) {
+				IMolecule a = m.getMolecule(i);
+				sdg.setMolecule((IMolecule)a);
+				sdg.generateCoordinates(new Vector2d(0,1));
+				//clean valencies, otherwise JCP shows valencies (e.g. C(v4) ) on every atom
+				for (IAtom atom : sdg.getMolecule().atoms())
+					atom.setValency(null);
+				m.replaceAtomContainer(i, MoleculeTools.copyChangeBuilders(sdg.getMolecule(),builder4jcp));
+			}
+		}
+		return m;		
+	}
+	public String getFilename() {
+		return filename;
+	}
+
+	protected ListOfAtomContainers getContainers() {
+		return containers;
+	}
+
+
+}

data/Toxtree-v2.6.13/src/toxTree/data/ObjectPropertyFilter.java

@@ -0,0 +1,210 @@
+/*
+Copyright (C) 2005-2006  
+
+Contact: nina@acad.bg
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public License
+as published by the Free Software Foundation; either version 2.1
+of the License, or (at your option) any later version.
+All we ask is that proper credit is given for our work, which includes
+- but is not limited to - adding the above copyright notice to the beginning
+of your source code files, and to any copyright notice that you may distribute
+with programs based on this work.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
+*/
+
+package toxTree.data;
+
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.LayoutManager;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.FocusEvent;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+
+import javax.swing.BorderFactory;
+import javax.swing.BoxLayout;
+import javax.swing.JComboBox;
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+
+import org.openscience.cdk.interfaces.IChemObject;
+
+import toxTree.exceptions.FilterException;
+
+public class ObjectPropertyFilter extends AbstractFilter {
+	public static String p_tag = "tag";
+	public static String p_value="value";
+	public ObjectPropertyFilter() throws FilterException {
+		super();
+	}
+	public ObjectPropertyFilter(Object key, Object value) throws FilterException {
+		this();
+        if ((key ==null) || (key.equals(""))) 
+            throw new FilterException("The condition \""+key+"\"=\""+value+"\" can not be created!");
+		setProperty(p_tag, key);
+		setProperty(p_value, value);
+	}
+    
+	@Override
+	public void setProperties(Map properties) {
+		
+		Iterator i = properties.keySet().iterator();
+		while (i.hasNext()) {
+			Object key = i.next();
+			setProperty(key.toString(), properties.get(key));
+		}
+	}
+	
+	@Override
+	public void setProperty(String key, Object value) {
+		if (p_tag.equals(key) || p_value.equals(key))
+			super.setProperty(key, value);
+		//else ignore
+	}
+	public boolean accept(IChemObject object) {
+		Object key = parameters.get(p_tag);
+		return acceptProperty(object.getProperty(key));
+	}
+
+
+	public boolean acceptProperty(Object value) {
+		try {
+			if (value == null) return false;
+            Object values = parameters.get(p_value);
+            if (values instanceof Collection)
+                return ((Collection)values).contains(value);
+            else return values.toString().equals(value.toString());
+		} catch (Exception x) {
+			x.printStackTrace();
+			return false;
+		}
+		
+		//return this.value.equals(value);
+	}	
+
+	@Override
+	public String toString() {
+		return parameters.toString();
+	}
+	public Object getTag() {
+		return getProperty(p_tag);
+	}
+	public void setTag(Object property) {
+		setProperty(p_tag,property);
+		
+	}
+	public Object getValue() {
+		return getProperty(p_value);
+	}
+	public void setValue(Object property) {
+		setProperty(p_value,property);
+		
+	}
+	@Override
+	public boolean equals(Object arg0) {
+		ObjectPropertyFilter pf = (ObjectPropertyFilter) arg0;
+		return getTag().equals(pf.getTag())  && getValue().equals(pf.getValue());
+	}
+	@Override
+	public JComponent getEditor() {
+		return new ObjectPropertyFilterEditor("",this);
+	}
+	
+
+}
+
+class ObjectPropertyFilterEditor extends AbstractFilterEditor implements ActionListener {
+	/**
+     * 
+     */
+    private static final long serialVersionUID = 4964600959825654563L;
+    protected JLabel keyLabel;
+	protected JComboBox keyField;
+	protected JLabel valueLabel;
+	protected JComboBox valueField;
+	public ObjectPropertyFilterEditor(String title,  ObjectPropertyFilter filter) {
+		this(new FlowLayout(),title,filter);
+	}
+	public ObjectPropertyFilterEditor(LayoutManager layout,String title,  ObjectPropertyFilter filter) {
+		super(layout,title,filter);
+		setLayout(new BoxLayout(this,BoxLayout.PAGE_AXIS));
+		Object key = filter.getProperty(ObjectPropertyFilter.p_tag);
+		if (key == null) filter.setProperty(ObjectPropertyFilter.p_tag,""); key = "";
+		keyField = new JComboBox(new String[] {key.toString()});
+        keyField.setSelectedIndex(0);
+		keyField.addActionListener(this);
+		keyField.addFocusListener(this);
+		keyField.setPreferredSize(new Dimension(100,24));
+        keyField.setMaximumSize(new Dimension(Integer.MAX_VALUE,24));
+		keyLabel = new JLabel("Parameter");
+		add(keyLabel);
+		add(keyField);
+		Object value = filter.getProperty(ObjectPropertyFilter.p_value);
+		if (value ==null) value = "";
+		valueField = new JComboBox(new String[] {value.toString()});
+        valueField.setPreferredSize(new Dimension(100,24));
+        valueField.setMaximumSize(new Dimension(Integer.MAX_VALUE,24));        
+        valueField.setSelectedIndex(0);
+		valueField.addFocusListener(this);
+		valueField.addActionListener(this);
+		//valueField.setPreferredSize(new Dimension(100,24));
+		valueLabel = new JLabel("Value");
+		add(valueLabel);
+		add(valueField);
+        setBorder(BorderFactory.createTitledBorder("Define group of compounds"));
+	}
+
+	@Override
+	public void setEditable(boolean editable) {
+		super.setEditable(editable);
+		keyField.setEditable(editable);
+		valueField.setEditable(editable);
+	}
+	protected void update(Object source) throws Exception {
+		if (source == keyField) {
+			((ObjectPropertyFilter) object).setProperty(ObjectPropertyFilter.p_tag, keyField.getSelectedItem().toString());
+		} else 
+		if (source == valueField) {
+			((ObjectPropertyFilter) object).setProperty(ObjectPropertyFilter.p_value, valueField.getSelectedItem().toString());
+		}
+		
+	}
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		super.actionPerformed(e);
+        try {
+		update(e.getSource());
+        } catch (Exception x) {
+            JOptionPane.showMessageDialog(this,x.getMessage(),"Error",JOptionPane.ERROR_MESSAGE);
+        }
+		
+	}
+	
+	@Override
+	public void focusLost(FocusEvent e) {
+		super.focusLost(e);
+        try {
+            update(e.getSource());
+            } catch (Exception x) {
+                JOptionPane.showMessageDialog(this,x.getMessage(),"Error",JOptionPane.ERROR_MESSAGE);
+            }
+	}
+    public void addTags(Object[] tags) {
+        for (int i=0; i < tags.length;i++)
+            keyField.addItem(tags[i]);
+    }
+}