- * @param shownTypes
- * a map, keyed by calcId (annotation source), whose entries are the
- * lists of annotation types found for the calcId; each annotation
- * type in turn may be a list (in the case of grouped annotations)
- * @param hiddenTypes
- * a map, similar to shownTypes, but for hidden annotation types
- * @param visibleGraphGroups
- * a lookup keyed by graphGroup identifier
- * @param annotations
- * the annotations on the alignment to scan
- * @param sequenceGroup
- * the sequence group to restrict search to
- */
- public static void getAnnotationTypesForShowHide(
- Map<String, List<List<String>>> shownTypes,
- Map<String, List<List<String>>> hiddenTypes,
- BitSet visibleGraphGroups, AlignmentAnnotation[] annotations,
- SequenceGroup sequenceGroup)
- {
- /*
- * Build a lookup, by calcId (annotation source), of all annotation types in
- * each graph group.
- */
- Map<String, Map<Integer, List<String>>> groupLabels = new HashMap<String, Map<Integer, List<String>>>();
-
- // trackers for which calcId!label combinations we have dealt with
- List<String> addedToShown = new ArrayList<String>();
- List<String> addedToHidden = new ArrayList<String>();
-
- for (AlignmentAnnotation aa : annotations)
- {
-
- if (sequenceGroup == null
- || (aa.sequenceRef != null && sequenceGroup.getSequences()
- .contains(aa.sequenceRef)))
- {
- String calcId = aa.getCalcId();
-
- /*
- * Build a 'composite label' for types in line graph groups.
- */
- final List<String> labelAsList = new ArrayList<String>();
- final String displayLabel = aa.label;
- labelAsList.add(displayLabel);
- if (aa.graph == AlignmentAnnotation.LINE_GRAPH
- && aa.graphGroup > -1)
- {
- if (!groupLabels.containsKey(calcId))
- {
- groupLabels.put(calcId, new HashMap<Integer, List<String>>());
- }
- Map<Integer, List<String>> groupLabelsForCalcId = groupLabels
- .get(calcId);
- if (groupLabelsForCalcId.containsKey(aa.graphGroup))
- {
- if (!groupLabelsForCalcId.get(aa.graphGroup).contains(
- displayLabel))
- {
- groupLabelsForCalcId.get(aa.graphGroup).add(displayLabel);
- }
- }
- else
- {
- groupLabelsForCalcId.put(aa.graphGroup, labelAsList);
- }
- }
- else
- /*
- * 'Simple case' - not a grouped annotation type - list of one label
- * only
- */
- {
- String rememberAs = calcId + "!" + displayLabel;
- if (aa.visible && !addedToShown.contains(rememberAs))
- {
- if (!shownTypes.containsKey(calcId))
- {
- shownTypes.put(calcId, new ArrayList<List<String>>());
- }
- shownTypes.get(calcId).add(labelAsList);
- addedToShown.add(rememberAs);
- }
- else
- {
- if (!aa.visible && !addedToHidden.contains(rememberAs))
- {
- if (!hiddenTypes.containsKey(calcId))
- {
- hiddenTypes.put(calcId, new ArrayList<List<String>>());
- }
- hiddenTypes.get(calcId).add(labelAsList);
- addedToHidden.add(rememberAs);
- }
- }
- }
- }
- }
- /*
- * finally add the 'composite group labels' to the appropriate lists,
- * depending on whether the group is identified as visible or hidden
- */
- for (String calcId : groupLabels.keySet())
- {
- for (int group : groupLabels.get(calcId).keySet())
- {
- final List<String> groupLabel = groupLabels.get(calcId).get(group);
- if (visibleGraphGroups.get(group))
- {
- if (!shownTypes.containsKey(calcId))
- {
- shownTypes.put(calcId, new ArrayList<List<String>>());
- }
- shownTypes.get(calcId).add(groupLabel);
- }
- else
- {
- if (!hiddenTypes.containsKey(calcId))
- {
- hiddenTypes.put(calcId, new ArrayList<List<String>>());
- }
- hiddenTypes.get(calcId).add(groupLabel);
- }
- }
- }
- }
-
- /**
- * Returns a BitSet (possibly empty) of those graphGroups for line graph
- * annotations, which have at least one member annotation row marked visible.
- * The logic is that only one row in the group is marked visible, but when it
- * is drawn, so are all the other rows in the same group.
- * <p/>
- * This lookup set allows us to check whether rows marked not visible are in
- * fact shown.
- *
- * @see AnnotationRenderer#drawComponent
- * @param annotations