/*
* 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.viewer;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.ComponentOrientation;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTextPane;
import javax.swing.JTree;
import javax.swing.Scrollable;
import javax.swing.event.TreeExpansionEvent;
import javax.swing.event.TreeExpansionListener;
import javax.swing.event.TreeWillExpandListener;
import javax.swing.text.BadLocationException;
import javax.swing.text.DefaultStyledDocument;
import javax.swing.text.Document;
import javax.swing.text.MutableAttributeSet;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyledDocument;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.ExpandVetoException;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import org.apache.uima.cas.ArrayFS;
import org.apache.uima.cas.CAS;
import org.apache.uima.cas.CASException;
import org.apache.uima.cas.FSIterator;
import org.apache.uima.cas.Feature;
import org.apache.uima.cas.FeatureStructure;
import org.apache.uima.cas.SofaFS;
import org.apache.uima.cas.Type;
import org.apache.uima.cas.impl.BooleanArrayFSImpl;
import org.apache.uima.cas.impl.ByteArrayFSImpl;
import org.apache.uima.cas.impl.DoubleArrayFSImpl;
import org.apache.uima.cas.impl.FloatArrayFSImpl;
import org.apache.uima.cas.impl.IntArrayFSImpl;
import org.apache.uima.cas.impl.LongArrayFSImpl;
import org.apache.uima.cas.impl.ShortArrayFSImpl;
import org.apache.uima.cas.impl.StringArrayFSImpl;
import org.apache.uima.cas.text.AnnotationFS;
import org.apache.uima.jcas.JCas;
import org.apache.uima.jcas.tcas.Annotation;
/**
* A Swing component that displays annotations in a text pane with highlighting. There is also a
* tree view for display details of annotations on which the user clicks. This class extends
* {@link JPanel} and so can be reused within any Swing application.
* <p>
* To launch the viewer, call the {@link #setCAS(CAS)} method with the CAS to be viewed.
* <p>
* The viewer is configurable via the following methods:
* <ul>
* <li>{@link #setConsistentColors(boolean)} - if set to true (default), the color assigned to any
* annotation type will be the same across all documents. If set to false, colors may vary across
* documents.</li>
* <li>{@link #setDisplayedTypes(String[])} - specifies a set of types that will be highlighted in
* the viewer's text pane.</li>
* <li>{@link #setHiddenTypes(String[])} - specifies a set of types that will NOT be highlighted in
* the viewer's text pane.</li>
* <li>{@link #setHiddenFeatures(String[])} - specifies a set of features that will never shown in
* the viewer's annotation details tree.</li>
* <li>{@link #setHighFrequencyTypes(String[])} - this can be used to specify a set of types that
* occur frequently. These types will the be assigned the most distinguishable colors.</li>
* <li>{@link #setInitiallySelectedTypes(String[])} - this can be used to specify a set of types
* that will initially be selected (i.e. have their checkboxes checked) in the viewer. The default
* is for all types to be initially selected.</li>
* <li>{@link #setRightToLeftTextOrientation(boolean)} - switches the text pane from left-to-right
* (default) to right-to-left mode. This is needed to support languages such as Arabic and Hebrew,
* which are read from right to left.</li>
* </ul>
*/
public class CasAnnotationViewer extends JPanel implements ActionListener, MouseListener,
TreeWillExpandListener, TreeExpansionListener, ItemListener {
private static final long serialVersionUID = 3559118488371946999L;
// Mode constants
private static final short MODE_ANNOTATIONS = 0;
private static final short MODE_ENTITIES = 1;
private ArrayList userTypes = null;
/**
* @return Returns the userTypes.
*/
public ArrayList getUserTypes() {
return userTypes;
}
/**
* @param userTypes
* The userTypes to set.
*/
public void setUserTypes(ArrayList userTypes) {
this.userTypes = userTypes;
}
// colors to use for highlighting annotations
// (use high brightness for best contrast against black text)
private static final float BRIGHT = 0.95f;
private static final Color[] COLORS = new Color[] {
// low saturation colors are best, so put them first
Color.getHSBColor(55f / 360, 0.25f, BRIGHT), // butter yellow?
Color.getHSBColor(0f / 360, 0.25f, BRIGHT), // pink?
Color.getHSBColor(210f / 360, 0.25f, BRIGHT), // baby blue?
Color.getHSBColor(120f / 360, 0.25f, BRIGHT), // mint green?
Color.getHSBColor(290f / 360, 0.25f, BRIGHT), // lavender?
Color.getHSBColor(30f / 360, 0.25f, BRIGHT), // tangerine?
Color.getHSBColor(80f / 360, 0.25f, BRIGHT), // celery green?
Color.getHSBColor(330f / 360, 0.25f, BRIGHT), // light coral?
Color.getHSBColor(160f / 360, 0.25f, BRIGHT), // aqua?
Color.getHSBColor(250f / 360, 0.25f, BRIGHT), // light violet?
// higher saturation colors
Color.getHSBColor(55f / 360, 0.5f, BRIGHT), Color.getHSBColor(0f / 360, 0.5f, BRIGHT),
Color.getHSBColor(210f / 360, 0.5f, BRIGHT), Color.getHSBColor(120f / 360, 0.5f, BRIGHT),
Color.getHSBColor(290f / 360, 0.5f, BRIGHT),
Color.getHSBColor(30f / 360, 0.5f, BRIGHT),
Color.getHSBColor(80f / 360, 0.5f, BRIGHT),
Color.getHSBColor(330f / 360, 0.5f, BRIGHT),
Color.getHSBColor(160f / 360, 0.5f, BRIGHT),
Color.getHSBColor(250f / 360, 0.5f, BRIGHT),
// even higher saturation colors
Color.getHSBColor(55f / 360, 0.75f, BRIGHT), Color.getHSBColor(0f / 360, 0.75f, BRIGHT),
Color.getHSBColor(210f / 360, 0.75f, BRIGHT), Color.getHSBColor(120f / 360, 0.75f, BRIGHT),
Color.getHSBColor(290f / 360, 0.75f, BRIGHT), Color.getHSBColor(30f / 360, 0.75f, BRIGHT),
Color.getHSBColor(80f / 360, 0.75f, BRIGHT), Color.getHSBColor(330f / 360, 0.75f, BRIGHT),
Color.getHSBColor(160f / 360, 0.75f, BRIGHT), Color.getHSBColor(250f / 360, 0.75f, BRIGHT) };
private static String[] DEFAULT_HIDDEN_FEATURES = { "sofa" };
private Map mTypeNameToColorMap = new HashMap();
private HashSet noCheckSet = new HashSet();
private List mHighFrequencyTypes = new ArrayList();
private Set mDisplayedTypeNames = null;
private Set mHiddenTypeNames = new HashSet();
private Set mInitiallySelectedTypeNames = null;
private Map mTypeToCheckboxMap = new HashMap();
private Map mEntityToCheckboxMap = new HashMap();
private CAS mCAS;
private Type mStringType;
private Type mFsArrayType;
private boolean mConsistentColors = true;
private Set mHiddenFeatureNames = new HashSet();
private boolean mEntityViewEnabled = false;
private short mViewMode = MODE_ANNOTATIONS;
private boolean mHideUnselectedCheckboxes = false;
// GUI components
private JSplitPane horizSplitPane;
private JSplitPane vertSplitPane;
private JScrollPane textScrollPane;
private JTextPane textPane;
private JPanel legendPanel;
private JLabel legendLabel;
private JScrollPane legendScrollPane;
private JPanel annotationCheckboxPanel;
private JPanel entityCheckboxPanel;
private JPanel buttonPanel;
private JButton selectAllButton;
private JButton deselectAllButton;
private JButton showHideUnselectedButton;
private JTree selectedAnnotationTree;
private DefaultTreeModel selectedAnnotationTreeModel;
private JPanel viewModePanel;
private JRadioButton annotationModeButton;
private JRadioButton entityModeButton;
private String[] mBoldfaceKeywords = new String[0];
private int[] mBoldfaceSpans = new int[0];
private JPanel sofaSelectionPanel;
private JComboBox sofaSelectionComboBox;
private EntityResolver mEntityResolver = new DefaultEntityResolver();
/**
* Creates a CAS Annotation Viewer.
*/
public CasAnnotationViewer() {
// create a horizonal JSplitPane
horizSplitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);
horizSplitPane.setResizeWeight(0.6);
this.setLayout(new BorderLayout());
this.add(horizSplitPane);
// create a vertical JSplitPane and add to left of horizSplitPane
vertSplitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
vertSplitPane.setResizeWeight(0.8);
vertSplitPane.setPreferredSize(new Dimension(620, 600));
vertSplitPane.setMinimumSize(new Dimension(200, 200));
horizSplitPane.setLeftComponent(vertSplitPane);
// add JTextPane to top of vertical split pane
textPane = new JTextPane();
textPane.setEditable(false);
textPane.setPreferredSize(new Dimension(620, 400));
textPane.setMinimumSize(new Dimension(200, 100));
textScrollPane = new JScrollPane(textPane);
vertSplitPane.setTopComponent(textScrollPane);
// bottom pane is the legend, with checkboxes
legendPanel = new JPanel();
legendPanel.setPreferredSize(new Dimension(620, 200));
legendPanel.setLayout(new BorderLayout());
legendLabel = new JLabel("Legend");
legendPanel.add(legendLabel, BorderLayout.NORTH);
// checkboxes are contained in a scroll pane
legendScrollPane = new JScrollPane();
legendScrollPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
legendPanel.add(legendScrollPane, BorderLayout.CENTER);
// there are two checkbox panels - one for annotations, one for entities
annotationCheckboxPanel = new VerticallyScrollablePanel();
annotationCheckboxPanel.setLayout(new GridLayout(0, 5));
entityCheckboxPanel = new VerticallyScrollablePanel();
entityCheckboxPanel.setLayout(new GridLayout(0, 4));
// add annotation panel first, since that is the default
legendScrollPane.setViewportView(annotationCheckboxPanel);
// at very bottom is the Button Panel, with Select All, Deselect All,
// and Hide/Show Unselected Buttons. It also may show the sofa-selection
// combo box and/or the Viewer Mode radio group; either are both may
// be hidden.
buttonPanel = new JPanel();
selectAllButton = new JButton("Select All");
selectAllButton.addActionListener(this);
buttonPanel.add(selectAllButton);
deselectAllButton = new JButton("Deselect All");
deselectAllButton.addActionListener(this);
buttonPanel.add(deselectAllButton);
showHideUnselectedButton = new JButton("Hide Unselected");
showHideUnselectedButton.addActionListener(this);
buttonPanel.add(showHideUnselectedButton);
sofaSelectionPanel = new JPanel();
JLabel sofaSelectionLabel = new JLabel("Sofa:");
sofaSelectionPanel.add(sofaSelectionLabel);
sofaSelectionComboBox = new JComboBox();
sofaSelectionPanel.add(sofaSelectionComboBox);
sofaSelectionComboBox.addItemListener(this);
buttonPanel.add(sofaSelectionPanel);
viewModePanel = new JPanel();
viewModePanel.add(new JLabel("Mode: "));
annotationModeButton = new JRadioButton("Annotations");
annotationModeButton.setSelected(true);
annotationModeButton.addActionListener(this);
viewModePanel.add(annotationModeButton);
entityModeButton = new JRadioButton("Entities");
entityModeButton.addActionListener(this);
viewModePanel.add(entityModeButton);
ButtonGroup group = new ButtonGroup();
group.add(annotationModeButton);
group.add(entityModeButton);
buttonPanel.add(viewModePanel);
viewModePanel.setVisible(false);
this.add(buttonPanel, BorderLayout.SOUTH);
textPane.setMinimumSize(new Dimension(200, 100));
vertSplitPane.setBottomComponent(legendPanel);
// right pane has a JTree
selectedAnnotationTreeModel = new DefaultTreeModel(new DefaultMutableTreeNode("Annotations"));
selectedAnnotationTree = new JTree(selectedAnnotationTreeModel) {
private static final long serialVersionUID = -7882967150283952907L;
public Dimension getPreferredScrollableViewportSize() {
return new Dimension(230, 500);
}
};
selectedAnnotationTree.setMinimumSize(new Dimension(50, 100));
selectedAnnotationTree.setScrollsOnExpand(true);
selectedAnnotationTree.setRootVisible(true);
selectedAnnotationTree.setCellRenderer(new AnnotationTreeCellRenderer());
selectedAnnotationTree.addTreeWillExpandListener(this);
selectedAnnotationTree.addTreeExpansionListener(this);
JPanel treePanel = new JPanel();
treePanel.setLayout(new BorderLayout());
treePanel.add(new JLabel("Click In Text to See Annotation Detail"), BorderLayout.NORTH);
treePanel.add(new JScrollPane(selectedAnnotationTree), BorderLayout.CENTER);
horizSplitPane.setRightComponent(treePanel);
// add mouse listener to update annotation tree
textPane.addMouseListener(this);
// initialize hidden feature names map
mHiddenFeatureNames.addAll(Arrays.asList(DEFAULT_HIDDEN_FEATURES));
}
/**
* @deprecated use the zero-argument constructor and call {@link #setEntityViewEnabled(boolean)}
*/
@Deprecated
public CasAnnotationViewer(boolean aEntityViewEnabled) {
this();
}
/**
* Set the list of types that occur most frequently. This method assigns the most distinguishable
* colors to these types.
*
* @param aTypeNames
* names of types that are occur frequently. Ideally these should be ordered by
* frequency, with the most frequent being first.
*/
public void setHighFrequencyTypes(String[] aTypeNames) {
// store these types for later
mHighFrequencyTypes.clear();
mHighFrequencyTypes.addAll(Arrays.asList(aTypeNames));
mTypeNameToColorMap.clear();
assignColors(mHighFrequencyTypes);
}
/**
* Set the list of types that will be highlighted in the viewer. Types not in this list will not
* appear in the legend and will never be highlighted. If this method is not called, the default
* is to show all types in the CAS (except those specifically hidden by a call to
* {@link #setHiddenTypes(String[])}.
*
* @param aTypeNames
* names of types that are to be highlighted. Null indicates that all types in the CAS
* should be highlighted.
*/
public void setDisplayedTypes(String[] aDisplayedTypeNames) {
if (aDisplayedTypeNames == null) {
mDisplayedTypeNames = null;
} else {
mDisplayedTypeNames = new HashSet();
mDisplayedTypeNames.addAll(Arrays.asList(aDisplayedTypeNames));
}
}
/**
* Set the list of types that will NOT be highlighted in the viewer.
*
* @param aTypeNames
* names of types that are never to be highlighted.
*/
public void setHiddenTypes(String[] aTypeNames) {
mHiddenTypeNames.clear();
mHiddenTypeNames.addAll(Arrays.asList(aTypeNames));
}
/**
* Configures the initially selected types in the viewer. If not called, all types will be
* initially selected.
*
* @param aTypeNames
* array of fully-qualified names of types to be initially selected
*/
public void setInitiallySelectedTypes(String[] aTypeNames) {
mInitiallySelectedTypeNames = new HashSet();
for (int i = 0; i < aTypeNames.length; i++) {
mInitiallySelectedTypeNames.add(aTypeNames[i]);
}
// apply to existing checkboxes
Iterator iterator = mTypeToCheckboxMap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry) iterator.next();
String type = ((Type) entry.getKey()).getName();
JCheckBox checkbox = (JCheckBox) entry.getValue();
checkbox.setSelected(typeNamesContains(mInitiallySelectedTypeNames, type));
}
// redisplay (if we have a CAS) - this allows this method to be called
// either before or after displaying the viewer
if (mCAS != null) {
display();
}
}
/**
* Configures the viewer to hide certain features in the annotation deatail pane.
*
* @param aFeatureName
* array of (short) feature names to be hidden
*/
public void setHiddenFeatures(String[] aFeatureNames) {
mHiddenFeatureNames.clear();
// add default hidden features
mHiddenFeatureNames.addAll(Arrays.asList(DEFAULT_HIDDEN_FEATURES));
// add user-defined hidden features
mHiddenFeatureNames.addAll(Arrays.asList(aFeatureNames));
}
/**
* Configures whether the viewer will allow the user to switch to "Entity" view, which highlight
* entities rather than annotations. Entity mode is typically only useful if the
* {@link #setEntityResolver(EntityResolver)} method has been called with a user-supplied
* class that can determine which annotations refer to the same entity.
*
* @param aDisplayEntities
* true to enable entity viewing mode, false to allow annotation viewing only.
* The default is false.
*/
public void setEntityViewEnabled(boolean aEnabled) {
mEntityViewEnabled = aEnabled;
this.viewModePanel.setVisible(aEnabled);
}
/**
* Sets the {@link EntityResolver} to use when the viewer is in entity mode.
* Entity mode must be turned on using the {@link #setEntityViewEnabled(boolean)} method.
* @param aEntityResolver user-supplied class that can determine which annotations correspond
* to the same entity.
*/
public void setEntityResolver(EntityResolver aEntityResolver) {
mEntityResolver = aEntityResolver;
}
/**
* Sets whether colors will be consistent in all documents viewed using this viewer. If set to
* true, assignments of color to annotation type will persist across documents; if false, colors
* will be reassigned in each new document. (Note that if high frequency types are set via
* {@link #setHighFrequencyTypes(String[])}, the colors for those types will always be
* consistent, regardless of the value passed to this method.
*
* @param aConsistent
* true (the default) causes colors to be consistent across documents, false allows them
* to vary
*/
public void setConsistentColors(boolean aConsistent) {
mConsistentColors = aConsistent;
}
/**
* Sets the text orientation. The default is left-to-right, but needs to be set to right-to-left
* to properly display some languages, most notably Arabic and Hebrew.
*
* @param aRightToLeft
* true to put the viewer in right-to-left mode, false for left-to-right (the default).
*/
public void setRightToLeftTextOrientation(boolean aRightToLeft) {
textPane.applyComponentOrientation(aRightToLeft ? ComponentOrientation.RIGHT_TO_LEFT
: ComponentOrientation.LEFT_TO_RIGHT);
}
/**
* Sets whether unselected (unchecked) checkboxes will be hidden entirely from the legend. This
* mode makes for a cleaner legend at the expense of making it more difficult to toggle which
* types are selected. There's also a button in the GUI that lets the user change this setting.
*
* @param aConsistent
* true (the default) causes colors to be consistent across documents, false allows them
* to vary
*/
public void setHideUnselectedCheckboxes(boolean aHideUnselected) {
mHideUnselectedCheckboxes = aHideUnselected;
display();
}
/**
* Sets the CAS to be viewed. This must be called before {@link #display()}.
*
* @param aCAS
* the CSA to be viewed
*/
public void setCAS(CAS aCAS) {
mCAS = aCAS;
mStringType = mCAS.getTypeSystem().getType(CAS.TYPE_NAME_STRING);
mFsArrayType = mCAS.getTypeSystem().getType(CAS.TYPE_NAME_FS_ARRAY);
// clear checkbox panel so it will be repopulated
annotationCheckboxPanel.removeAll();
entityCheckboxPanel.removeAll();
mTypeToCheckboxMap.clear();
mEntityToCheckboxMap.clear();
// clear selected annotation details tree
this.updateSelectedAnnotationTree(-1);
// clear type to color map if color consistency is off
if (!mConsistentColors) {
mTypeNameToColorMap.clear();
// but reassign colors to high frequency types
assignColors(mHighFrequencyTypes);
}
// clear boldface
mBoldfaceKeywords = new String[0];
mBoldfaceSpans = new int[0];
// enable or disable entity view depending on user's choice
this.viewModePanel.setVisible(mEntityViewEnabled);
// Populate sofa combo box with the names of all text Sofas in the CAS
sofaSelectionComboBox.removeAllItems();
Iterator sofas = aCAS.getSofaIterator();
Feature sofaIdFeat = aCAS.getTypeSystem().getFeatureByFullName(CAS.FEATURE_FULL_NAME_SOFAID);
boolean nonDefaultSofaFound = false;
while (sofas.hasNext()) {
SofaFS sofa = (SofaFS) sofas.next();
if (sofa.getLocalStringData() != null) {
String sofaId = sofa.getStringValue(sofaIdFeat);
if (CAS.NAME_DEFAULT_SOFA.equals(sofaId)) {
sofaId = "DEFAULT"; // make nicer display
} else {
nonDefaultSofaFound = true;
}
sofaSelectionComboBox.addItem(sofaId);
// if this sofa matches the view passed to this method, select it
CAS viewOfSofa = aCAS.getView(sofa);
if (viewOfSofa == aCAS) {
sofaSelectionComboBox.setSelectedIndex(sofaSelectionComboBox.getItemCount() - 1);
}
}
}
if (sofaSelectionComboBox.getItemCount() == 0) {
throw new RuntimeException("This CAS contains no document to view.");
}
// make sofa selector visible if any text sofa other than the default was found
sofaSelectionPanel.setVisible(nonDefaultSofaFound);
// Note that selection of the Sofa from the combo box happens during
// population, and that triggers the call to display() to display
// that document and its annotations/entities.
// display();
}
/**
* Causes the specified words to appear in boldface wherever they occur in the document. This is
* case-insensitive. Call this method after {@link #setCAS()}. It wil apply only to the current
* document, and will be reset on the next call to {@link #setCAS()}.
*
* @param aWords
* array of words to highlight in boldface.
*/
public void applyBoldfaceToKeywords(String[] aWords) {
mBoldfaceKeywords = aWords;
doBoldface();
}
/**
* Causes the specified spans to appear in boldface. This is case-insensitive. Call this method
* after {@link #setCAS()}. It wil apply only to the current document, and will be reset on the
* next call to {@link #setCAS()}.
*
* @param aSpans
* spans to appear in boldface (begin1, end1, begin2, end2, ...)
*/
public void applyBoldfaceToSpans(int[] aSpans) {
mBoldfaceSpans = aSpans;
doBoldface();
}
/**
* Configures the viewer appropriately for displaying a hit against an XML fragments query. This
* does not use a sophisticated algorithm for determining the location of the document that
* matched the query. Currently all it does is call {@link #setInitiallySelectedTypes(String[])}
* with the list of types mentioned in the query and {@link #applyBoldfaceToKeyword(String[])} on
* any keywords mentioned in the query.
*
* @param aQuery
* an XML fragments query
* @param aTypeNamespace
* namespace to prepend to the element names in the query in order to form
* fully-qualified CAS type names. This is optional; if not specified, type namespaces
* are ignored and any type whose local name matches the query will be selected.
*/
public void configureViewForXmlFragmentsQuery(String aQuery, String aTypeNamespace) {
// need to parse query and produce type list and keyword list
List typeList = new ArrayList();
List keywordList = new ArrayList();
String delims = "<>+-*\" \t\n";
StringTokenizer tokenizer = new StringTokenizer(aQuery, delims, true);
boolean inTag = false;
while (tokenizer.hasMoreTokens()) {
String tok = tokenizer.nextToken();
if ("<".equals(tok)) {
inTag = true;
} else if (">".equals(tok) && inTag) {
inTag = false;
} else if (delims.indexOf(tok) == -1) // token is not a delimiter
{
if (inTag) {
if (!tok.startsWith("/")) // ignore end tags
{
if (tok.endsWith("/")) {
tok = tok.substring(0, tok.length() - 1); // strip trailing / from empty tags
}
typeList.add(aTypeNamespace + '.' + tok);
}
} else {
keywordList.add(tok);
}
}
}
// System.out.println(typeList);
// System.out.println(keywordList);
setInitiallySelectedTypes((String[]) typeList.toArray(new String[0]));
display();
applyBoldfaceToKeywords((String[]) keywordList.toArray(new String[0]));
}
/**
* Configures the viewer appropriately for displaying a hit against an XML fragments query. This
* does not use a sophisticated algorithm for determining the location of the document that
* matched the query. Currently all it does is call {@link #setInitiallySelectedTypes(String[])}
* with the list of types mentioned in the query and {@link #applyBoldfaceToKeyword(String[])} on
* any keywords mentioned in the query.
*
* @param aQuery
* an XML fragments query
*/
public void configureViewForXmlFragmentsQuery(String aQuery) {
configureViewForXmlFragmentsQuery(aQuery, "*");
}
/**
* Assign initially checked to the specified types, pairing up down the lists
*
* @param aNotChecked
* list of types not to be initially checked JMP
*/
public void assignCheckedFromList(ArrayList aNotChecked) {
Iterator iterC = aNotChecked.iterator();
while (iterC.hasNext()) {
String typeName = (String) iterC.next();
// assign to list of types not to be initially checked
noCheckSet.add(typeName);
}
}
/**
* Assign colors to the specified types, pairing up down the lists
*
* @param aColors
* list of colors
* @param aTypeNames
* list of type names JMP
*/
public void assignColorsFromList(List aColors, ArrayList aTypeNames) {
// populate mTypeNameToColorMap
Iterator iter = aTypeNames.iterator();
Iterator iterC = aColors.iterator();
while (iter.hasNext()) {
if (!iterC.hasNext())
break;
String typeName = (String) iter.next();
Color color = (Color) iterC.next();
// assign background color
mTypeNameToColorMap.put(typeName, color);
}
setUserTypes(aTypeNames);
// clear checkbox panel so it will be refreshed
annotationCheckboxPanel.removeAll();
mTypeToCheckboxMap.clear();
}
/**
* Assign colors to the specified types
*
* @param aTypeNames
* list of type names
*/
private void assignColors(List aTypeNames) {
// populate mTypeNameToColorMap
Iterator iter = aTypeNames.iterator();
while (iter.hasNext()) {
String typeName = (String) iter.next();
// assign background color
Color c = COLORS[mTypeNameToColorMap.size() % COLORS.length];
mTypeNameToColorMap.put(typeName, c);
}
// clear checkbox panel so it will be refreshed
annotationCheckboxPanel.removeAll();
mTypeToCheckboxMap.clear();
}
/**
* Creates/updates the display. This is called when setCAS() is called and again each time to
* user's mode or checkbox selections change.
*/
private void display() {
// remember split pane divider location so we can restore it later
int dividerLoc = vertSplitPane.getDividerLocation();
// remember caret pos and scroll position
int caretPos = this.textPane.getCaretPosition();
int verticalScrollPos = this.textScrollPane.getVerticalScrollBar().getValue();
// type of display depends on whether we are in annotation or entity mode
switch (mViewMode) {
case MODE_ANNOTATIONS:
displayAnnotations();
break;
case MODE_ENTITIES:
displayEntities();
break;
}
// apply boldface to keywords and spans as indicated by user
doBoldface();
// update the label of the Show/Hide Unselected Button
if (mHideUnselectedCheckboxes) {
showHideUnselectedButton.setText("Show Unselected");
} else {
showHideUnselectedButton.setText("Hide Unselected");
}
// reset scroll position
textPane.setCaretPosition(caretPos);
textScrollPane.getVerticalScrollBar().setValue(verticalScrollPos);
textScrollPane.revalidate();
// reset split pane divider
vertSplitPane.setDividerLocation(dividerLoc);
}
/**
* Creates the annotation display.
*/
private void displayAnnotations() {
// for speed, detach document from text pane before updating
StyledDocument doc = (StyledDocument) textPane.getDocument();
Document blank = new DefaultStyledDocument();
textPane.setDocument(blank);
// make sure annotationCheckboxPanel is showing
if (legendScrollPane.getViewport().getView() != annotationCheckboxPanel) {
legendScrollPane.setViewportView(annotationCheckboxPanel);
}
// add text from CAS
try {
doc.remove(0, doc.getLength());
doc.insertString(0, mCAS.getDocumentText(), new SimpleAttributeSet());
} catch (BadLocationException e) {
throw new RuntimeException(e);
}
// Iterate over annotations
FSIterator iter = mCAS.getAnnotationIndex().iterator();
Hashtable checkBoxes = new Hashtable();
HashSet checkBoxesDone = new HashSet();
while (iter.isValid()) {
AnnotationFS fs = (AnnotationFS) iter.get();
iter.moveToNext();
Type type = fs.getType();
// have we seen this type before?
JCheckBox checkbox = (JCheckBox) mTypeToCheckboxMap.get(type);
if (checkbox == null) {
// check that type should be displayed
if ((mDisplayedTypeNames == null || typeNamesContains(mDisplayedTypeNames, type.getName()))
&& !typeNamesContains(mHiddenTypeNames, type.getName())) {
// if mTypeNameToColorMap exists, get color from there
Color c = (Color) mTypeNameToColorMap.get(type.getName());
if (c == null) // assign next available color
{
c = COLORS[mTypeNameToColorMap.size() % COLORS.length];
mTypeNameToColorMap.put(type.getName(), c);
}
// This next section required until priorities work properly
// HashSet noCheckSet = new HashSet();
String noCheckArray[] = {
// "org.apache.jresporator.PROPER",
// "DOCSTRUCT_ANNOT_TYPE",
// "VOCAB_ANNOT_TYPE"
};
for (int i = 0; i < noCheckArray.length; i++) {
noCheckSet.add(noCheckArray[i]);
}
// end of section
// should type be initially selected?
boolean selected = ((mInitiallySelectedTypeNames == null &&
// document annotation is not initially selected in default case
!CAS.TYPE_NAME_DOCUMENT_ANNOTATION.equals(type.getName()) && !noCheckSet
.contains(type.getName()) // priorities JMP
) || (mInitiallySelectedTypeNames != null && typeNamesContains(
mInitiallySelectedTypeNames, type.getName())));
// add checkbox
checkbox = new JCheckBox(type.getShortName(), selected);
checkbox.setToolTipText(type.getName());
checkbox.addActionListener(this);
checkbox.setBackground(c);
// annotationCheckboxPanel.add(checkbox); do it later JMP
checkBoxes.put(type.getName(), checkbox);
checkBoxesDone.add(checkbox);
// add to (Type, Checkbox) map
mTypeToCheckboxMap.put(type, checkbox);
} else {
// this type is not hidden, skip it
continue;
}
}
// if checkbox is checked, assign color to text
if (checkbox.isSelected()) {
int begin = fs.getBegin();
int end = fs.getEnd();
// Be careful of 0-length annotations and annotations that span the
// entire document. In either of these cases, if we try to set
// background color, it will set the input text style, which is not
// what we want.
if (begin == 0 && end == mCAS.getDocumentText().length()) {
end--;
}
if (begin < end) {
MutableAttributeSet attrs = new SimpleAttributeSet();
StyleConstants.setBackground(attrs, checkbox.getBackground());
doc.setCharacterAttributes(begin, end - begin, attrs, false);
}
}
}
// now populate panel with checkboxes in order specified in user file. JMP
ArrayList aTypeNames = getUserTypes();
if (aTypeNames != null) {
Iterator iterT = aTypeNames.iterator();
while (iterT.hasNext()) {
String typeName = (String) iterT.next();
JCheckBox cb = (JCheckBox) checkBoxes.get(typeName);
if (cb != null) {
annotationCheckboxPanel.add(cb);
checkBoxesDone.remove(cb);
}
}
}
// add additional checkboxes in alphabetical order
LinkedList checkboxes = new LinkedList(checkBoxesDone);
Collections.sort(checkboxes, new Comparator() {
public int compare(Object o1, Object o2) {
return ((JCheckBox) o1).getText().toLowerCase().compareTo(
((JCheckBox) o2).getText().toLowerCase());
}
});
Iterator iterC = checkboxes.iterator();
while (iterC.hasNext()) {
JCheckBox cb = (JCheckBox) iterC.next();
annotationCheckboxPanel.add(cb);
}
// add/remove checkboxes from display as determined by the
// mHideUnselectedCheckboxes toggle
Iterator cbIter = mTypeToCheckboxMap.values().iterator();
while (cbIter.hasNext()) {
JCheckBox cb = (JCheckBox) cbIter.next();
if (mHideUnselectedCheckboxes && !cb.isSelected()) {
if (cb.getParent() == annotationCheckboxPanel) {
annotationCheckboxPanel.remove(cb);
}
} else if (cb.getParent() != annotationCheckboxPanel) {
annotationCheckboxPanel.add(cb);
}
}
// reattach document to text pane
textPane.setDocument(doc);
}
/**
* Creates the entity display.
*/
private void displayEntities() {
// for speed, detach document from text pane before updating
StyledDocument doc = (StyledDocument) textPane.getDocument();
Document blank = new DefaultStyledDocument();
textPane.setDocument(blank);
// make sure entityCheckboxPanel is showing
if (legendScrollPane.getViewport().getView() != entityCheckboxPanel) {
legendScrollPane.setViewportView(entityCheckboxPanel);
}
// add text from CAS
try {
doc.remove(0, doc.getLength());
doc.insertString(0, mCAS.getDocumentText(), new SimpleAttributeSet());
} catch (BadLocationException e) {
throw new RuntimeException(e);
}
// Iterate over EntityAnnotations using JCAS, because the EntityResolver interface
// uses JCAS as a convenience to the user.
JCas jcas;
try {
// NOTE: for a large type system, this can take a few seconds, which results in a
// noticeable delay when the user first switches to Entity mode.
jcas = mCAS.getJCas();
} catch (CASException e) {
throw new RuntimeException(e);
}
FSIterator iter = jcas.getAnnotationIndex().iterator();
while (iter.isValid()) {
Annotation annot = (Annotation) iter.get();
iter.moveToNext();
// find out what entity this annotation represents
EntityResolver.Entity entity = mEntityResolver.getEntity(annot);
//if not an entity, skip it
if (entity == null)
continue;
// have we seen this entity before?
JCheckBox checkbox = (JCheckBox) mEntityToCheckboxMap.get(entity);
if (checkbox == null) {
// assign next available color
Color c = COLORS[mEntityToCheckboxMap.size() % COLORS.length];
// add checkbox
checkbox = new JCheckBox(entity.getCanonicalForm(), true);
checkbox.setToolTipText(entity.getCanonicalForm());
checkbox.addActionListener(this);
checkbox.setBackground(c);
entityCheckboxPanel.add(checkbox);
// add to (Entity, Checkbox) map
mEntityToCheckboxMap.put(entity, checkbox);
}
// if checkbox is checked, assign color to text
if (checkbox.isSelected()) {
int begin = annot.getBegin();
int end = annot.getEnd();
// be careful of 0-length annotation. If we try to set background color when there
// is no selection, it will set the input text style, which is not what we want.
if (begin != end) {
MutableAttributeSet attrs = new SimpleAttributeSet();
StyleConstants.setBackground(attrs, checkbox.getBackground());
doc.setCharacterAttributes(begin, end - begin, attrs, false);
}
}
}
// add/remove checkboxes from display as determined by the
// mHideUnselectedCheckboxes toggle
Iterator cbIter = mEntityToCheckboxMap.values().iterator();
while (cbIter.hasNext()) {
JCheckBox cb = (JCheckBox) cbIter.next();
if (mHideUnselectedCheckboxes && !cb.isSelected()) {
if (cb.getParent() == entityCheckboxPanel) {
entityCheckboxPanel.remove(cb);
}
} else if (cb.getParent() != entityCheckboxPanel) {
entityCheckboxPanel.add(cb);
}
}
// reattach document to text pane
textPane.setDocument(doc);
}
/**
* Refreshes the selected annotation tree.
*
* @param aPosition
* the currently selected offset into the document. All annotations overlapping this
* point will be rendered in the tree.
*/
private void updateSelectedAnnotationTree(int aPosition) {
DefaultMutableTreeNode root = (DefaultMutableTreeNode) this.selectedAnnotationTreeModel
.getRoot();
root.removeAllChildren();
FSIterator annotIter = this.mCAS.getAnnotationIndex().iterator();
while (annotIter.isValid()) {
AnnotationFS annot = (AnnotationFS) annotIter.get();
// if (getPanePosition(annot.getBegin()) <= aPosition
// && getPanePosition(annot.getEnd()) > aPosition)
if (annot.getBegin() <= aPosition && annot.getEnd() > aPosition) {
JCheckBox checkbox = (JCheckBox) mTypeToCheckboxMap.get(annot.getType());
if (checkbox != null && checkbox.isSelected()) {
addAnnotationToTree(annot);
}
}
// else if (getPanePosition(annot.getBegin()) > aPosition)
else if (annot.getBegin() > aPosition)
break;
annotIter.moveToNext();
}
this.selectedAnnotationTreeModel.nodeStructureChanged(root);
// expand first level
// int row = 0;
// while (row < this.selectedAnnotationTree.getRowCount())
// {
// if (this.selectedAnnotationTree.getPathForRow(row).getPathCount() <= 2)
// {
// this.selectedAnnotationTree.expandRow(row);
// }
// row++;
// }
// hmmm.. how to get scroll pane to resize properly??
this.selectedAnnotationTree.treeDidChange();
// this.selectedAnnotationTree.setPreferredSize(this.selectedAnnotationTree.getSize());
this.selectedAnnotationTree.revalidate();
this.horizSplitPane.revalidate();
}
/**
* Adds an annotation to the selected annotations tree. Annotations in the tree are grouped by
* type.
*
* @param aAnnotation
* the annotation to add
*/
protected void addAnnotationToTree(AnnotationFS aAnnotation) {
DefaultMutableTreeNode root = (DefaultMutableTreeNode) this.selectedAnnotationTreeModel
.getRoot();
// try to find a node for the type
DefaultMutableTreeNode typeNode = null;
Enumeration typeNodes = root.children();
while (typeNodes.hasMoreElements()) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) typeNodes.nextElement();
if (aAnnotation.getType().equals(((TypeTreeNodeObject) node.getUserObject()).getType())) {
typeNode = node;
break;
}
}
if (typeNode == null) {
typeNode = new DefaultMutableTreeNode(new TypeTreeNodeObject(aAnnotation.getType()));
root.insert(typeNode, 0);
}
// add annotation node
DefaultMutableTreeNode annotationNode = new DefaultMutableTreeNode(new FsTreeNodeObject(
aAnnotation, null));
typeNode.insert(annotationNode, 0);
// add child nodes for features
addFeatureTreeNodes(annotationNode, aAnnotation);
}
private void addFeatureTreeNodes(DefaultMutableTreeNode aParentNode, FeatureStructure aFS) {
List aFeatures = aFS.getType().getFeatures();
Iterator iter = aFeatures.iterator();
while (iter.hasNext()) {
Feature feat = (Feature) iter.next();
String featName = feat.getShortName();
// skip hidden features
if (mHiddenFeatureNames.contains(featName)) {
continue;
}
// how we get feature value depends on feature's range type)
String featVal = "null";
Type rangeType = feat.getRange();
String rangeTypeName = rangeType.getName();
if (mCAS.getTypeSystem().subsumes(mStringType, rangeType)) {
featVal = aFS.getStringValue(feat);
if (featVal == null) {
featVal = "null";
} else if (featVal.length() > 64) {
featVal = featVal.substring(0, 64) + "...";
}
} else if (rangeType.isPrimitive()) {
featVal = aFS.getFeatureValueAsString(feat);
} else if (mCAS.getTypeSystem().subsumes(mFsArrayType, rangeType)) {
ArrayFS arrayFS = (ArrayFS) aFS.getFeatureValue(feat);
if (arrayFS != null) {
// Add featName = FSArray node, then add each array element as a child
DefaultMutableTreeNode arrayNode = new DefaultMutableTreeNode(featName + " = FSArray");
for (int i = 0; i < arrayFS.size(); i++) {
FeatureStructure fsVal = arrayFS.get(i);
if (fsVal != null) {
// Add the FS node and a dummy child, so that user can expand it.
// When user expands it, new nodes for feature values will be created.
DefaultMutableTreeNode fsValNode = new DefaultMutableTreeNode(new FsTreeNodeObject(
fsVal, featName));
if (!fsVal.getType().getFeatures().isEmpty()) {
fsValNode.add(new DefaultMutableTreeNode(null));
}
arrayNode.add(fsValNode);
} else {
arrayNode.add(new DefaultMutableTreeNode("null"));
}
}
aParentNode.add(arrayNode);
continue;
}
} else if (rangeType.isArray()) // primitive array
{
String[] vals = null;
if (CAS.TYPE_NAME_STRING_ARRAY.equals(rangeTypeName)) {
StringArrayFSImpl arrayFS = (StringArrayFSImpl) aFS.getFeatureValue(feat);
if (arrayFS != null)
vals = arrayFS.toArray();
} else if (CAS.TYPE_NAME_INTEGER_ARRAY.equals(rangeTypeName)) {
IntArrayFSImpl arrayFS = (IntArrayFSImpl) aFS.getFeatureValue(feat);
if (arrayFS != null)
vals = arrayFS.toStringArray();
} else if (CAS.TYPE_NAME_FLOAT_ARRAY.equals(rangeTypeName)) {
FloatArrayFSImpl arrayFS = (FloatArrayFSImpl) aFS.getFeatureValue(feat);
if (arrayFS != null)
vals = arrayFS.toStringArray();
} else if (CAS.TYPE_NAME_BOOLEAN_ARRAY.equals(rangeTypeName)) {
BooleanArrayFSImpl arrayFS = (BooleanArrayFSImpl) aFS.getFeatureValue(feat);
if (arrayFS != null)
vals = arrayFS.toStringArray();
} else if (CAS.TYPE_NAME_BYTE_ARRAY.equals(rangeTypeName)) {
ByteArrayFSImpl arrayFS = (ByteArrayFSImpl) aFS.getFeatureValue(feat);
if (arrayFS != null)
vals = arrayFS.toStringArray();
} else if (CAS.TYPE_NAME_SHORT_ARRAY.equals(rangeTypeName)) {
ShortArrayFSImpl arrayFS = (ShortArrayFSImpl) aFS.getFeatureValue(feat);
if (arrayFS != null)
vals = arrayFS.toStringArray();
} else if (CAS.TYPE_NAME_LONG_ARRAY.equals(rangeTypeName)) {
LongArrayFSImpl arrayFS = (LongArrayFSImpl) aFS.getFeatureValue(feat);
if (arrayFS != null)
vals = arrayFS.toStringArray();
}
if (CAS.TYPE_NAME_DOUBLE_ARRAY.equals(rangeTypeName)) {
DoubleArrayFSImpl arrayFS = (DoubleArrayFSImpl) aFS.getFeatureValue(feat);
if (arrayFS != null)
vals = arrayFS.toStringArray();
}
if (vals == null) {
featVal = "null";
} else {
StringBuffer displayVal = new StringBuffer();
displayVal.append('[');
for (int i = 0; i < vals.length - 1; i++) {
displayVal.append(vals[i]);
displayVal.append(',');
}
if (vals.length > 0) {
displayVal.append(vals[vals.length - 1]);
}
displayVal.append(']');
featVal = displayVal.toString();
}
} else
// single feature value
{
FeatureStructure fsVal = aFS.getFeatureValue(feat);
if (fsVal != null) {
// Add the FS node and a dummy child, so that user can expand it.
// When user expands it, new nodes for feature values will be created.
DefaultMutableTreeNode fsValNode = new DefaultMutableTreeNode(new FsTreeNodeObject(fsVal,
featName));
if (!fsVal.getType().getFeatures().isEmpty()) {
fsValNode.add(new DefaultMutableTreeNode(null));
}
aParentNode.add(fsValNode);
continue;
}
}
aParentNode.add(new DefaultMutableTreeNode(featName + " = " + featVal));
}
}
/**
* Does wildcard matching to determine if a give type name is "contained" in a Set of type names.
*
* @param names
* Type names, which may include wildcards (e.g, uima.tt.*)
* @param name
* A type name
* @return True iff name matches a name in type names
*/
private boolean typeNamesContains(Set names, String name) {
if (names.contains(name))
return true;
else {
Iterator namesIterator = names.iterator();
while (namesIterator.hasNext()) {
String otherName = (String) namesIterator.next();
if (otherName.indexOf('*') != -1) {
if (wildCardMatch(name, otherName)) {
return true;
}
} else {
if (otherName.equalsIgnoreCase(name)) {
return true;
}
}
}
}
return false;
}
/**
* Helper for {@link #typeNamesContains(HashSet, String)}.
*
* @param s
* A litteral string
* @param pattern
* A string that includes one or more *'s as wildcards
* @return True iff the string matches the pattern.
*/
private boolean wildCardMatch(String s, String pattern) {
StringBuffer regexpPatternBuffer = new StringBuffer();
for (int i = 0; i < pattern.length(); i++) {
char c = pattern.charAt(i);
if (c == '*')
regexpPatternBuffer.append('.');
else if (c == '.')
regexpPatternBuffer.append('\\');
if (Character.isLetter(c)) {
regexpPatternBuffer.append('(').append(Character.toLowerCase(c)).append('|').append(
Character.toUpperCase(c)).append(')');
} else {
regexpPatternBuffer.append(c);
}
}
return s.matches(new String(regexpPatternBuffer));
}
/**
* @see java.awt.Component#setSize(Dimension)
*/
public void setSize(Dimension d) {
super.setSize(d);
Insets insets = getInsets();
Dimension paneSize = new Dimension(d.width - insets.left - insets.right, d.height - insets.top
- insets.bottom);
horizSplitPane.setPreferredSize(paneSize);
horizSplitPane.setSize(paneSize);
}
/*
* (non-Javadoc)
*
* @see java.awt.event.ActionListener#actionPerformed(java.awt.event.ActionEvent)
*/
public void actionPerformed(ActionEvent e) {
if (e.getSource() == selectAllButton) {
Iterator cbIter = (mViewMode == MODE_ANNOTATIONS) ? mTypeToCheckboxMap.values().iterator()
: mEntityToCheckboxMap.values().iterator();
while (cbIter.hasNext()) {
((JCheckBox) cbIter.next()).setSelected(true);
}
display();
} else if (e.getSource() == deselectAllButton) {
Iterator cbIter = (mViewMode == MODE_ANNOTATIONS) ? mTypeToCheckboxMap.values().iterator()
: mEntityToCheckboxMap.values().iterator();
while (cbIter.hasNext()) {
((JCheckBox) cbIter.next()).setSelected(false);
}
display();
} else if (e.getSource() == annotationModeButton) {
mViewMode = MODE_ANNOTATIONS;
display();
} else if (e.getSource() == entityModeButton) {
mViewMode = MODE_ENTITIES;
display();
// make sure we clear the annotation tree when we go into entity mode
// this.updateSelectedAnnotationTree(0);
} else if (e.getSource() == showHideUnselectedButton) {
mHideUnselectedCheckboxes = !mHideUnselectedCheckboxes;
display();
} else if (e.getSource() instanceof JCheckBox) {
display();
}
}
/*
* (non-Javadoc)
*
* @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
*/
public void mouseClicked(MouseEvent e) {
if (mViewMode == MODE_ANNOTATIONS) {
int pos = textPane.viewToModel(e.getPoint());
this.updateSelectedAnnotationTree(pos);
}
}
/*
* (non-Javadoc)
*
* @see java.awt.event.MouseListener#mouseEntered(java.awt.event.MouseEvent)
*/
public void mouseEntered(MouseEvent e) {
}
/*
* (non-Javadoc)
*
* @see java.awt.event.MouseListener#mouseExited(java.awt.event.MouseEvent)
*/
public void mouseExited(MouseEvent e) {
}
/*
* (non-Javadoc)
*
* @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
*/
public void mousePressed(MouseEvent e) {
}
/*
* (non-Javadoc)
*
* @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
*/
public void mouseReleased(MouseEvent e) {
}
/**
* Inner class containing data for a tree node representing a FeatureStructure
*/
static class FsTreeNodeObject {
public FsTreeNodeObject(FeatureStructure aFS, String aFeatureName) {
mFS = aFS;
mFeatureName = aFeatureName;
mCaption = mFS.getType().getShortName();
if (mFS instanceof AnnotationFS) {
String coveredText = ((AnnotationFS) mFS).getCoveredText();
if (coveredText.length() > 64)
coveredText = coveredText.substring(0, 64) + "...";
mCaption += " (\"" + coveredText + "\")";
}
if (mFeatureName != null) {
mCaption = mFeatureName + " = " + mCaption;
}
}
public FeatureStructure getFS() {
return mFS;
}
public String toString() {
return mCaption;
}
private FeatureStructure mFS;
private String mFeatureName;
private String mCaption;
}
/**
* Inner class containing data for a tree node representing a Type
*/
static class TypeTreeNodeObject {
public TypeTreeNodeObject(Type aType) {
mType = aType;
}
public Type getType() {
return mType;
}
public String toString() {
return mType.getShortName();
}
private Type mType;
}
class AnnotationTreeCellRenderer extends DefaultTreeCellRenderer {
private static final long serialVersionUID = -8661556785397184756L;
/*
* (non-Javadoc)
*
* @see javax.swing.tree.TreeCellRenderer#getTreeCellRendererComponent(javax.swing.JTree,
* java.lang.Object, boolean, boolean, boolean, int, boolean)
*/
public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel,
boolean expanded, boolean leaf, int row, boolean aHasFocus) {
// set background color if this is an Annotation or a Type
Color background = null;
if (value instanceof DefaultMutableTreeNode) {
Object userObj = ((DefaultMutableTreeNode) value).getUserObject();
Type type = null;
if (userObj instanceof FsTreeNodeObject) {
FeatureStructure fs = ((FsTreeNodeObject) userObj).getFS();
type = fs.getType();
} else if (userObj instanceof TypeTreeNodeObject) {
type = ((TypeTreeNodeObject) userObj).getType();
}
if (type != null) {
// look up checkbox to get color
JCheckBox checkbox = (JCheckBox) mTypeToCheckboxMap.get(type);
if (checkbox != null) {
background = checkbox.getBackground();
}
}
}
this.setBackgroundNonSelectionColor(background);
this.setBackgroundSelectionColor(background);
Component component = super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf,
row, aHasFocus);
return component;
}
}
/*
* (non-Javadoc)
*
* @see javax.swing.event.TreeWillExpandListener#treeWillCollapse(javax.swing.event.TreeExpansionEvent)
*/
public void treeWillCollapse(TreeExpansionEvent event) throws ExpandVetoException {
}
/*
* (non-Javadoc)
*
* @see javax.swing.event.TreeWillExpandListener#treeWillExpand(javax.swing.event.TreeExpansionEvent)
*/
public void treeWillExpand(TreeExpansionEvent event) throws ExpandVetoException {
// if FS node is expanded and it has a dummy child, replace with
// feature value nodes (this is what lets us do infinite tree)
Object lastPathComponent = event.getPath().getLastPathComponent();
if (lastPathComponent instanceof DefaultMutableTreeNode) {
DefaultMutableTreeNode expandedNode = (DefaultMutableTreeNode) lastPathComponent;
Object userObj = expandedNode.getUserObject();
if (userObj instanceof FsTreeNodeObject) {
TreeNode firstChild = expandedNode.getFirstChild();
if (firstChild instanceof DefaultMutableTreeNode
&& ((DefaultMutableTreeNode) firstChild).getUserObject() == null) {
expandedNode.removeAllChildren();
FeatureStructure fs = ((FsTreeNodeObject) userObj).getFS();
addFeatureTreeNodes(expandedNode, fs);
((JTree) event.getSource()).treeDidChange();
}
}
}
}
/*
* (non-Javadoc)
*
* @see javax.swing.event.TreeExpansionListener#treeCollapsed(javax.swing.event.TreeExpansionEvent)
*/
public void treeCollapsed(TreeExpansionEvent event) {
}
/*
* (non-Javadoc)
*
* @see javax.swing.event.TreeExpansionListener#treeExpanded(javax.swing.event.TreeExpansionEvent)
*/
public void treeExpanded(TreeExpansionEvent event) {
// if a Type node is expanded and has only one child,
// also expand this child (a usability improvement)
Object lastPathComponent = event.getPath().getLastPathComponent();
if (lastPathComponent instanceof DefaultMutableTreeNode) {
DefaultMutableTreeNode expandedNode = (DefaultMutableTreeNode) lastPathComponent;
Object userObj = expandedNode.getUserObject();
if (userObj instanceof TypeTreeNodeObject && expandedNode.getChildCount() == 1) {
TreePath childPath = event.getPath().pathByAddingChild(expandedNode.getFirstChild());
((JTree) event.getSource()).expandPath(childPath);
((JTree) event.getSource()).treeDidChange();
}
}
}
/*
* (non-Javadoc)
*
* @see java.awt.event.ItemListener#itemStateChanged(java.awt.event.ItemEvent)
*/
public void itemStateChanged(ItemEvent e) {
if (e.getSource() == sofaSelectionComboBox) {
// a new sofa was selected. Switch to that view and update display
String sofaId = (String) e.getItem();
if ("DEFAULT".equals(sofaId)) {
mCAS = mCAS.getView(CAS.NAME_DEFAULT_SOFA);
} else {
mCAS = mCAS.getView(sofaId);
}
display();
}
}
/**
* Applies boldface as per the mBoldfaceKeywords and mBoldfaceSpans fields.
*/
private void doBoldface() {
// Keywords
if (mBoldfaceKeywords.length > 0) {
// build regular expression
StringBuffer regEx = new StringBuffer();
for (int i = 0; i < mBoldfaceKeywords.length; i++) {
if (i > 0) {
regEx.append('|');
}
regEx.append("\\b");
String word = mBoldfaceKeywords[i];
for (int j = 0; j < word.length(); j++) {
char c = word.charAt(j);
if (Character.isLetter(c)) {
regEx.append('[').append(Character.toLowerCase(c)).append(Character.toUpperCase(c))
.append(']');
} else if (c == '.' || c == '^' || c == '&' || c == '\\' || c == '(' || c == ')') {
regEx.append('\\').append(c);
} else {
regEx.append('c');
}
}
regEx.append("\\b");
}
// System.out.println("RegEx: " + regEx);
Pattern pattern = Pattern.compile(regEx.toString());
Matcher matcher = pattern.matcher(mCAS.getDocumentText());
// match
int pos = 0;
while (matcher.find(pos)) {
MutableAttributeSet attrs = new SimpleAttributeSet();
StyleConstants.setBold(attrs, true);
StyledDocument doc = (StyledDocument) textPane.getDocument();
doc.setCharacterAttributes(matcher.start(), matcher.end() - matcher.start(), attrs, false);
if (pos == matcher.end()) // infinite loop check
break;
else
pos = matcher.end();
}
}
// Spans
int docLength = mCAS.getDocumentText().length();
int len = mBoldfaceSpans.length;
len -= len % 2; // to avoid ArrayIndexOutOfBoundsException if some numbskull passes in an
// odd-length array
int i = 0;
while (i < len) {
int begin = mBoldfaceSpans[i];
int end = mBoldfaceSpans[i + 1];
if (begin >= 0 && begin <= docLength && end >= 0 && end <= docLength) {
MutableAttributeSet attrs = new SimpleAttributeSet();
StyleConstants.setBold(attrs, true);
StyledDocument doc = (StyledDocument) textPane.getDocument();
doc.setCharacterAttributes(begin, end - begin, attrs, false);
}
i += 2;
}
}
/**
* Gets the selected annotation tree component.
*
* @return the tree that displays annotation details about annotations overlapping the point where
* the user last clicked in the text.
*/
protected JTree getSelectedAnnotationTree() {
return this.selectedAnnotationTree;
}
/**
* A panel that is to be placed in a JScrollPane that can only scroll vertically. This panel
* should have its width track the viewport's width, and increase its height as necessary to
* display all components.
*
*
*/
static class VerticallyScrollablePanel extends JPanel implements Scrollable {
private static final long serialVersionUID = 1009744410018634511L;
/*
* (non-Javadoc)
*
* @see javax.swing.Scrollable#getPreferredScrollableViewportSize()
*/
public Dimension getPreferredScrollableViewportSize() {
return getPreferredSize();
}
/*
* (non-Javadoc)
*
* @see javax.swing.Scrollable#getScrollableBlockIncrement(java.awt.Rectangle, int, int)
*/
public int getScrollableBlockIncrement(Rectangle visibleRect, int orientation, int direction) {
return 50;
}
/*
* (non-Javadoc)
*
* @see javax.swing.Scrollable#getScrollableTracksViewportHeight()
*/
public boolean getScrollableTracksViewportHeight() {
return false;
}
/*
* (non-Javadoc)
*
* @see javax.swing.Scrollable#getScrollableTracksViewportWidth()
*/
public boolean getScrollableTracksViewportWidth() {
return true;
}
/*
* (non-Javadoc)
*
* @see javax.swing.Scrollable#getScrollableUnitIncrement(java.awt.Rectangle, int, int)
*/
public int getScrollableUnitIncrement(Rectangle visibleRect, int orientation, int direction) {
return 10;
}
}
/**
* Trivial entity resolver that's applied if the user turns on entity mode without
* specifying their own entity resolver. Returns the covered text as the canonical form,
* and treats annotations with equal covered text as belonging to the same entity.
*/
static class DefaultEntityResolver implements EntityResolver {
/* (non-Javadoc)
* @see org.apache.uima.tools.viewer.EntityResolver#getCanonicalForm(org.apache.uima.jcas.tcas.Annotation)
*/
public Entity getEntity(final Annotation aAnnotation) {
return new Entity() {
public String getCanonicalForm() {
return aAnnotation.getCoveredText();
}
public boolean equals(Object obj) {
if (obj instanceof Entity) {
String canon = ((Entity)obj).getCanonicalForm();
return getCanonicalForm().equals(canon);
}
return false;
}
public int hashCode() {
return getCanonicalForm().hashCode();
}
};
}
}
}