| /* |
| * 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); |
| } |
| |
| } |
