/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.tools.stylemap;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FontMetrics;
import java.awt.Insets;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Vector;
import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.table.TableColumn;
import org.apache.uima.analysis_engine.AnalysisEngineDescription;
import org.apache.uima.analysis_engine.metadata.AnalysisEngineMetaData;
import org.apache.uima.cas.CAS;
import org.apache.uima.tools.images.Images;
import org.apache.uima.tools.util.gui.ImageButton;
import org.apache.uima.tools.util.htmlview.AnnotationViewGenerator;
/**
* A GUI for editing style maps for the annotation viewer.
* <p>
* A style map is an XML document that describes how each kind of output from a Text Analysis Engine
* is to be displayed in the annotation viewer. Each output type that the user wants to be displayed
* will have an entry in the style map. Each entry in the style map contains:
* <ul>
* <li>The CSS style used to display annotations of that type (for example "background:blue;
* color:white;" to display white text on a blue background.</li>
* <li>A label used to identify the annotations in the annotation viewer</li>
* </ul>
* <p>
* To invoke the editor, call the {@link launchEditor(TextAnalysisEngine,String)} method.
*
*
*
*/
public class StyleMapEditor extends JDialog implements ActionListener {
private static final long serialVersionUID = -7774771368169207250L;
private boolean buttonPress = false;
private boolean populated;
private AnnotationFeaturesViewer annotationFeaturesViewer;
private ImageButton addTableEntryButton;
private StyleMapTableModel tableModel;
private StyleMapTable annotationsTable;
private ArrayList styleList;
private ImageButton removeTableRowButton;
private ImageButton moveRowUpButton;
private ImageButton moveRowDownButton;
private JButton okButton = new JButton("Save");
private JButton cancelButton = new JButton("Cancel");
private JButton resetButton = new JButton("Reset");
private JDialog styleMapEditorDialog;
private HashMap colorNameMap;
private AnalysisEngineMetaData analysisEngineMetaData;
private AnalysisEngineDescription ae;
private TableGUIMediator med;
// data for data model
Object[][] data;
/**
*
* Creates a new `Editor.
*/
public StyleMapEditor(final JFrame aOwner, CAS cas) {
super(aOwner, "Style Map Editor", true);
populated = false; // table not yet loaded
styleList = new ArrayList();
// Save this in class member variable for use by inner-classes:
styleMapEditorDialog = this;
getContentPane().setLayout(new BorderLayout());
JPanel annotationFeaturesPanel = new JPanel();
annotationFeaturesPanel.setLayout(new BorderLayout());
annotationFeaturesViewer = new AnnotationFeaturesViewer();
annotationFeaturesPanel.add(annotationFeaturesViewer, BorderLayout.CENTER);
JPanel iconPanel = new JPanel();
addTableEntryButton = new ImageButton(Images.FORWARD);
addTableEntryButton.setToolTipText("Create stylemap table entry");
addTableEntryButton.addActionListener(this);
iconPanel.add(addTableEntryButton);
annotationFeaturesPanel.add(iconPanel, BorderLayout.EAST);
JPanel tablePanel = new JPanel();
tablePanel.setLayout(new BorderLayout());
JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true,
annotationFeaturesPanel, tablePanel);
Dimension screenDimension = getToolkit().getScreenSize();
splitPane.setDividerLocation((int) (screenDimension.width * 0.28));
okButton.setToolTipText("Save stylemap and exit");
cancelButton.setToolTipText("Exit without saving");
resetButton.setToolTipText("Reset stylemap to that auto-generated from metadata");
JPanel buttonsPanel = new JPanel();
buttonsPanel.add(okButton);
buttonsPanel.add(cancelButton);
buttonsPanel.add(resetButton);
getContentPane().add(splitPane, BorderLayout.CENTER);
getContentPane().add(buttonsPanel, BorderLayout.SOUTH);
// creating a jtable to hold the styles
tableModel = new StyleMapTableModel(StyleConstants.columnNames);
med = new TableGUIMediator();
annotationsTable = new StyleMapTable(tableModel, annotationFeaturesViewer, this, med);
med.setTable(annotationsTable);
annotationsTable.setDefaultRenderer(Color.class, new ColorRenderer(annotationsTable));
setUpColorEditor(annotationsTable);
annotationsTable.setDefaultEditor(String.class, new LabelCellEditor());
final JScrollPane scrollPane = new JScrollPane();
scrollPane.getViewport().add(annotationsTable, null);
tablePanel.add(scrollPane, BorderLayout.CENTER);
JPanel tableButtonsPanel = new JPanel();
moveRowUpButton = new ImageButton(Images.UP);
moveRowUpButton.setToolTipText("Move Row Up");
moveRowUpButton.addActionListener(this);
tableButtonsPanel.add(moveRowUpButton);
moveRowDownButton = new ImageButton(Images.DOWN);
moveRowDownButton.setToolTipText("Move Row Down");
moveRowDownButton.addActionListener(this);
tableButtonsPanel.add(moveRowDownButton);
removeTableRowButton = new ImageButton(Images.ROW_DELETE);
removeTableRowButton.setToolTipText("Delete Row");
removeTableRowButton.addActionListener(this);
tableButtonsPanel.add(removeTableRowButton);
// pass all these to the mediator which turns them on and off
med.setButtons(moveRowUpButton, moveRowDownButton, removeTableRowButton);
tablePanel.add(tableButtonsPanel, BorderLayout.NORTH);
MyCellRenderer cellRenderer = new MyCellRenderer();
TableColumn tc = annotationsTable.getColumnModel().getColumn(0);
tc.setCellRenderer(cellRenderer);
TableColumn labelTableColumn = annotationsTable.getColumnModel().getColumn(
StyleConstants.LABEL_COLUMN);
TableColumn typeNameTableColumn = annotationsTable.getColumnModel().getColumn(
StyleConstants.TYPE_NAME_COLUMN);
// TableColumn featureValueTableColumn =
// annotationsTable.getColumnModel().getColumn(StyleConstants.FEATURE_VALUE_COLUMN);
labelTableColumn.setCellRenderer(cellRenderer);
typeNameTableColumn.setCellRenderer(cellRenderer);
// featureValueTableColumn.setCellRenderer(cellRenderer);
// Style Edit OK Button event handle
okButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
Vector vn = new Vector();
for (int row = 0; row < styleList.size(); row++) {
StyleMapEntry e = (StyleMapEntry) styleList.get(row);
e.setAnnotationTypeName("" + tableModel.getValueAt(row, StyleConstants.TYPE_NAME_COLUMN));
e.setLabel("" + tableModel.getValueAt(row, StyleConstants.LABEL_COLUMN));
// e.setFeatureValue( "" + tableModel.getValueAt(row,
// StyleConstants.FEATURE_VALUE_COLUMN));
vn.add(e.getLabel());
}
buttonPress = true;
Vector noDups = new Vector();
Object obj = null;
for (Iterator itr = vn.iterator(); itr.hasNext();) {
obj = itr.next();
if ((obj != null) && !obj.equals("")) {
if (noDups.contains(obj)) {
JOptionPane.showMessageDialog(StyleMapEditor.this, ("Duplicate Label : " + obj
+ "\n" + "Change the Label and click OK!"), "Duplicate Values",
JOptionPane.PLAIN_MESSAGE);
buttonPress = false;
break;
} else {
noDups.addElement(obj);
}
}
}
if (buttonPress)
styleMapEditorDialog.setVisible(false);
}
});
// Style Edit Exit Button Event Handling
cancelButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evt) {
buttonPress = false;
styleMapEditorDialog.setVisible(false);
}
});
resetButton.addActionListener(this);
pack();
}
public Dimension getPreferredSize() {
Dimension screenSize = getToolkit().getScreenSize();
Dimension d = super.getPreferredSize();
return new Dimension(screenSize.width, d.height);
// return getToolkit().getScreenSize();
}
/**
* @deprecated use {@link #setAnalysisEngine(AnalysisEngineDescription)} instead.
*/
public void setTextAnalysisEngine(org.apache.uima.analysis_engine.TaeDescription tae) {
this.ae = tae;
}
public void setAnalysisEngine(AnalysisEngineDescription ae) {
this.ae = ae;
}
/**
* Displays the StyleMapEditor GUI and allows the user to edit a style map. When the user has
* finished, the new style map is returned.
*
* @param aAnalysisEngineMetaData
* Metadata for the AnalysisEngine whose style map is to be edited. This contains the
* AE's capabilities and type system definition, which are needed by the editor.
* @param aStyleMapXml
* An existing style map XML document that will be loaded into the editor. This is
* optional, if null is passed in, a default style map will be automatically generated
* from the AE metadata.
*
* @return a new style map XML document. If the user cancels, null is returned.
*/
public String launchEditor(AnalysisEngineMetaData aAnalysisEngineMetaData, String aStyleMapXml,
CAS cas) {
analysisEngineMetaData = aAnalysisEngineMetaData;
// create an ArrayList of style entries used by the GUI
ArrayList styleList = createStyleList(aAnalysisEngineMetaData, aStyleMapXml);
// display the GUI and allow user to interact with it (modifying the styleList)
if (launchGUI(styleList, cas)) {
// user clicked OK, so produce a new style map XML doc from the style list
return generateStyleMap(styleList);
} else {
// user cancelled; return null
return null;
}
}
/**
* Creates a List of StyleMapEntry objects from the given AnalysisEngineMetaData and style map
* XML.
*
* @param aAnalysisEngineMetaData
* Metadata for the AnalysisEngine whose style map is being edited.
* @param aStyleMapXml
* An existing style map XML document. This is optional, if null is passed in, a default
* style map will be automatically generated.
*
* @return an ArrayList containing one {@link StyleMapEntry} object for each output type declared
* in <code>aTaeMetaData</code>.
*/
public ArrayList createStyleList(AnalysisEngineMetaData aAnalysisEngineMetaData,
String aStyleMapXml) {
styleList = new ArrayList();
// Parse the style map XML and create StyleMapEntry elements appropriately.
// Note: we need to support the HTML color names as well as their hex codes;
// we could do that by hardcoding a hashmap with color names as keys and
// the corresponding Color objects as values.
// If stylemap XML is null, auto-generate it from metadata capabilities:
if (aStyleMapXml == null)
aStyleMapXml = AnnotationViewGenerator.autoGenerateStyleMap(aAnalysisEngineMetaData);
return parseStyleList(aStyleMapXml);
}
public ArrayList parseStyleList(String aStyleMapXml) {
StyleMapXmlParser smxp = new StyleMapXmlParser(aStyleMapXml);
// System.out.println(aStyleMapXml );
Vector annotType_SME = smxp.annotType;
Vector styleLabel_SME = smxp.styleLabel;
Vector featureValue_SME = smxp.featureValue;
Vector styleColor_SME = smxp.styleColor;
ColorParser cp = new ColorParser();
colorNameMap = cp.getColorNameMap();
for (int i = 0; i < annotType_SME.size(); i++) {
String typeName = ((String) annotType_SME.elementAt(i));
String labelString = ((String) styleLabel_SME.elementAt(i));
String featureValue = ((String) featureValue_SME.elementAt(i));
String styleColor = styleColor_SME.elementAt(i).toString();
StyleMapEntry e = cp.parseAndAssignColors(typeName, featureValue, labelString, styleColor);
styleList.add(e);
}
return styleList;
}
public void actionPerformed(ActionEvent evt) {
JComponent source = (JComponent) evt.getSource();
if (source == moveRowUpButton) {
int selectedRow = annotationsTable.getSelectedRow();
if (selectedRow == -1) {
JOptionPane.showMessageDialog(source, "Select table row", "Error",
JOptionPane.ERROR_MESSAGE);
return;
} else if (selectedRow == 0) {
Toolkit.getDefaultToolkit().beep();
} else {
tableModel.moveRowUp(selectedRow);
ListSelectionModel lsm = annotationsTable.getSelectionModel();
int newSelectedRow = selectedRow - 1;
lsm.setSelectionInterval(newSelectedRow, newSelectedRow);
StyleMapEntry e = (StyleMapEntry) styleList.get(selectedRow);
styleList.remove(selectedRow);
styleList.add(newSelectedRow, e);
}
} else if (source == moveRowDownButton) {
int selectedRow = annotationsTable.getSelectedRow();
if (selectedRow == -1) {
JOptionPane.showMessageDialog(source, "Select table row", "Error",
JOptionPane.ERROR_MESSAGE);
return;
} else if (selectedRow == (tableModel.getRowCount() - 1)) {
Toolkit.getDefaultToolkit().beep();
} else {
tableModel.moveRowDown(selectedRow);
ListSelectionModel lsm = annotationsTable.getSelectionModel();
int newSelectedRow = selectedRow + 1;
lsm.setSelectionInterval(newSelectedRow, newSelectedRow);
StyleMapEntry e = (StyleMapEntry) styleList.get(selectedRow);
styleList.remove(selectedRow);
styleList.add(newSelectedRow, e);
}
} else if (source == addTableEntryButton) {
String typeName = annotationFeaturesViewer.getSelection();
if (typeName == null) {
JOptionPane.showMessageDialog(source,
"You must first select an annotation type or feature", "Error",
JOptionPane.ERROR_MESSAGE);
return;
}
addRow(typeName);
} else if (source == removeTableRowButton) {
int row = annotationsTable.getSelectedRow();
if (row >= 0) {
String message = "Are you sure you want to remove "
+ tableModel.getValueAt(row, StyleConstants.LABEL_COLUMN);
int rv = JOptionPane.showConfirmDialog(removeTableRowButton, message, "Remove Table Row",
JOptionPane.YES_NO_OPTION);
if (rv == JOptionPane.YES_OPTION) {
styleList.remove(row);
styleList.trimToSize();
tableModel.removeRow(row);
ListSelectionModel lsm = annotationsTable.getSelectionModel();
int newSelectedRow = (row == styleList.size() ? (row - 1) : row);
lsm.setSelectionInterval(newSelectedRow, newSelectedRow);
}
} else {
JOptionPane.showMessageDialog(source, "You must first select a table row to remove",
"Error", JOptionPane.ERROR_MESSAGE);
}
} else if (source == resetButton) {
styleList = createStyleList(analysisEngineMetaData, null);
data = new Object[styleList.size()][StyleConstants.NR_TABLE_COLUMNS];
for (int x = 0; x < styleList.size(); x++) {
StyleMapEntry e = (StyleMapEntry) styleList.get(x);
data[x][0] = "";
data[x][StyleConstants.LABEL_COLUMN] = e.getLabel().trim();
data[x][StyleConstants.TYPE_NAME_COLUMN] = e.getAnnotationTypeName();
// data[x][StyleConstants.FEATURE_VALUE_COLUMN] = e.getFeatureValue();
data[x][StyleConstants.BG_COLUMN] = e.getBackground();
data[x][StyleConstants.FG_COLUMN] = e.getForeground();
data[x][StyleConstants.CHECK_COLUMN] = Boolean.valueOf(e.getChecked());
data[x][StyleConstants.HIDDEN_COLUMN] = Boolean.valueOf(e.getHidden());
}
tableModel.set(data);
tableModel.fireTableDataChanged();
}
}
protected StyleMapTable getAnnotationsTable() {
return this.annotationsTable;
}
/**
* Displays the Style Map Editor GUI and allows the user to interact with it.
*
* @param aStyleList
* an ArrayList containing the style map entries to be edited. When the user modifies a
* setting in the GUI, the elements of this List will be updated.
*
* @return true if the user exits the dialog by clicking the OK button, false if the user has
* clicked the Cancel button.
*/
private boolean launchGUI(ArrayList aStyleList, CAS cas) {
if (!populated) {
// populate and display GUI here, then wait for user to click OK or Cancel
styleList = aStyleList;
data = new Object[aStyleList.size()][StyleConstants.NR_TABLE_COLUMNS];
int maxColumnWidths[] = new int[StyleConstants.NR_TABLE_COLUMNS];
maxColumnWidths[0] = 16;
FontMetrics fm = annotationsTable.getFontMetrics(annotationsTable.getFont());
// maxColumnWidths[StyleConstants.FEATURE_VALUE_COLUMN] =
// fm.stringWidth(StyleConstants.columnNames[StyleConstants.FEATURE_VALUE_COLUMN]);
maxColumnWidths[StyleConstants.BG_COLUMN] = fm
.stringWidth(StyleConstants.columnNames[StyleConstants.BG_COLUMN]);
maxColumnWidths[StyleConstants.FG_COLUMN] = fm
.stringWidth(StyleConstants.columnNames[StyleConstants.FG_COLUMN]);
maxColumnWidths[StyleConstants.CHECK_COLUMN] = 60;
maxColumnWidths[StyleConstants.HIDDEN_COLUMN] = 60;
for (int x = 0; x < aStyleList.size(); x++) {
StyleMapEntry e = (StyleMapEntry) aStyleList.get(x);
data[x][0] = "";
data[x][StyleConstants.LABEL_COLUMN] = e.getLabel().trim();
data[x][StyleConstants.TYPE_NAME_COLUMN] = e.getAnnotationTypeName();
// data[x][StyleConstants.FEATURE_VALUE_COLUMN] = e.getFeatureValue();
data[x][StyleConstants.BG_COLUMN] = e.getBackground();
data[x][StyleConstants.FG_COLUMN] = e.getForeground();
data[x][StyleConstants.CHECK_COLUMN] = Boolean.valueOf(e.getChecked());
data[x][StyleConstants.HIDDEN_COLUMN] = Boolean.valueOf(e.getHidden());
// Calculate adequate column widths:
int typeNameWidth = fm.stringWidth(e.getAnnotationTypeName());
if (typeNameWidth > maxColumnWidths[StyleConstants.TYPE_NAME_COLUMN])
maxColumnWidths[StyleConstants.TYPE_NAME_COLUMN] = typeNameWidth;
int labelWidth = fm.stringWidth(e.getLabel().trim());
if (labelWidth > maxColumnWidths[StyleConstants.LABEL_COLUMN])
maxColumnWidths[StyleConstants.LABEL_COLUMN] = labelWidth;
}
tableModel.set(data);
tableModel.fireTableDataChanged();
annotationFeaturesViewer.populate(ae, analysisEngineMetaData, cas);
annotationFeaturesViewer.addTreeSelectionListener(new AnTreeListener(med));
med.setEntryButton(addTableEntryButton);
// Establish sensible column widths based upon data:
TableColumn column = null;
for (int i = 0; i < StyleConstants.NR_TABLE_COLUMNS; i++) {
column = annotationsTable.getColumnModel().getColumn(i);
column.setPreferredWidth(maxColumnWidths[i] + 4);
}
annotationsTable.getTableHeader().repaint();
populated = true; // only load table once
}
styleMapEditorDialog.pack();
styleMapEditorDialog.setVisible(true);
return buttonPress;
}
private void setUpColorEditor(JTable table) {
final JTable tbl = table;
// First, set up the button that brings up the dialog.
final JButton button = new JButton("") {
private static final long serialVersionUID = 3955120051470642157L;
public void setText(String s) {
// Button never shows text -- only color.
}
};
button.setBackground(Color.white);
button.setBorderPainted(false);
button.setMargin(new Insets(0, 0, 0, 0));
// Now create an editor to encapsulate the button, and
// set it up as the editor for all Color cells.
final ColorEditor colorEditor = new ColorEditor(button);
table.setDefaultEditor(Color.class, colorEditor);
// Set up the dialog that the button brings up.
final JColorChooser colorChooser = new JColorChooser();
// AbstractColorChooserPanel panels[] = colorChooser.getChooserPanels();
// The following has the effect of removing the RGB panel and making the HSB panel the default:
// AbstractColorChooserPanel preferredPanels[] = new AbstractColorChooserPanel[2];
// preferredPanels[0] = panels[1];
// preferredPanels[1] = panels[0];
// colorChooser.setChooserPanels(preferredPanels);
ActionListener okListener = new ActionListener() {
public void actionPerformed(ActionEvent e) {
colorEditor.currentColor = colorChooser.getColor();
Color newColor = colorEditor.currentColor;
StyleMapEntry entry = (StyleMapEntry) styleList.get(tbl.getSelectedRow());
int column = tbl.getSelectedColumn();
if (column == StyleConstants.BG_COLUMN)
entry.setBackground(newColor);
else
entry.setForeground(newColor);
tbl.repaint();
}
};
final JDialog dialog = JColorChooser.createDialog(button, "Pick a Color", true, colorChooser,
okListener, null);
// Here's the code that brings up the dialog.
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
button.setBackground(colorEditor.currentColor);
colorChooser.setColor(colorEditor.currentColor);
// Without the following line, the dialog comes up
// in the middle of the screen.
dialog.setLocationRelativeTo(button);
dialog.show();
}
});
}
/**
* Generates a style map XML document from the style list.
*
* @param aStyleList
* An ArrayList containing the style map entries to be written to XML.
*
* @return A style map XML document representing the information in <code>aStyleList</code>.
*/
private String generateStyleMap(ArrayList aStyleList) {
String newStyleMap = null;
try {
StringBuffer newStyle = new StringBuffer();
try {
newStyle.append("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
newStyle.append("<styleMap>\n");
Iterator smt = styleList.iterator();
for (int row = 0; smt.hasNext(); row++) {
StyleMapEntry e = (StyleMapEntry) smt.next();
newStyle.append("<rule>\n");
newStyle.append("<pattern>");
newStyle.append(e.getPattern());
newStyle.append("</pattern>\n");
newStyle.append("<label>");
String label = e.getLabel();
if (label != null) {
if ((label != null) && !label.equals(""))
newStyle.append(label);
else
newStyle.append(e.getAnnotationTypeName());
} else
newStyle.append(e.getAnnotationTypeName());
newStyle.append("</label>\n");
newStyle.append("<style>");
String foregroundColor = "#"
+ Integer.toHexString(e.getForeground().getRGB()).substring(2);
String backgroundColor = "#"
+ Integer.toHexString(e.getBackground().getRGB()).substring(2);
if (colorNameMap.containsKey(foregroundColor)) {
newStyle.append("color:" + colorNameMap.get(foregroundColor) + ";");
} else {
newStyle.append("color:" + foregroundColor + ";");
}
if (colorNameMap.containsKey(backgroundColor)) {
newStyle.append("background:" + colorNameMap.get(backgroundColor) + ";");
} else {
newStyle.append("background:" + backgroundColor + ";");
}
// add in checked and hidden
Boolean ck = (Boolean) tableModel.getValueAt(row, StyleConstants.CHECK_COLUMN);
String ckString = ck.toString();
Boolean hid = (Boolean) tableModel.getValueAt(row, StyleConstants.HIDDEN_COLUMN);
String hidString = hid.toString();
// this prevents hidden from being checked,
// becasue that is not a meaningful combination
if (hidString.equals("true")) {
ckString = "false";
}
newStyle.append("checked:" + ckString + ";");
newStyle.append("hidden:" + hidString + ";");
newStyle.append("</style>\n");
newStyle.append("</rule>\n");
}
newStyle.append("</styleMap>\n");
} catch (Exception e) {
System.out.println(e);
}
newStyleMap = newStyle.toString();
} catch (Throwable t) {
}
return newStyleMap;
}
public void addRow(String typeName) {
// Check for duplicate annotation types that are not feature values:
for (int i = 0; i < styleList.size(); i++) {
StyleMapEntry e = (StyleMapEntry) styleList.get(i);
if (typeName.equals(e.getAnnotationTypeName()) && typeName.indexOf(":") == -1) {
JOptionPane.showMessageDialog(StyleMapEditor.this, "Duplicate Annotation Type", "Error",
JOptionPane.ERROR_MESSAGE);
return;
}
}
StyleMapEntry styleMapEntry = new StyleMapEntry();
styleMapEntry.setAnnotationTypeName(typeName);
styleMapEntry.setLabel(typeName);
styleMapEntry.setFeatureValue("");
styleMapEntry.setForeground(Color.black);
styleMapEntry.setBackground(Color.white);
styleList.add(styleMapEntry);
// Create a Vector of values to be held in table data model:
Vector rowVector = new Vector();
rowVector.addElement("");
rowVector.addElement(typeName);
rowVector.addElement(typeName);
rowVector.addElement(Color.white);
rowVector.addElement(Color.black);
rowVector.addElement(Boolean.TRUE);
rowVector.addElement(Boolean.FALSE);
tableModel.addRow(rowVector);
}
}