src/jalview/gui/FeatureTypeSettings.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.gui;
  22
  23 import jalview.api.AlignmentViewPanel;
  24 import jalview.api.FeatureColourI;
  25 import jalview.datamodel.GraphLine;
  26 import jalview.datamodel.features.FeatureAttributes;
  27 import jalview.datamodel.features.FeatureAttributes.Datatype;
  28 import jalview.datamodel.features.FeatureMatcher;
  29 import jalview.datamodel.features.FeatureMatcherI;
  30 import jalview.datamodel.features.FeatureMatcherSet;
  31 import jalview.datamodel.features.FeatureMatcherSetI;
  32 import jalview.schemes.FeatureColour;
  33 import jalview.util.ColorUtils;
  34 import jalview.util.MessageManager;
  35 import jalview.util.matcher.Condition;
  36
  37 import java.awt.BorderLayout;
  38 import java.awt.Color;
  39 import java.awt.Dimension;
  40 import java.awt.FlowLayout;
  41 import java.awt.LayoutManager;
  42 import java.awt.event.ActionEvent;
  43 import java.awt.event.ActionListener;
  44 import java.awt.event.FocusAdapter;
  45 import java.awt.event.FocusEvent;
  46 import java.awt.event.ItemEvent;
  47 import java.awt.event.ItemListener;
  48 import java.awt.event.MouseAdapter;
  49 import java.awt.event.MouseEvent;
  50 import java.text.DecimalFormat;
  51 import java.util.ArrayList;
  52 import java.util.List;
  53
  54 import javax.swing.BorderFactory;
  55 import javax.swing.BoxLayout;
  56 import javax.swing.ButtonGroup;
  57 import javax.swing.JButton;
  58 import javax.swing.JCheckBox;
  59 import javax.swing.JColorChooser;
  60 import javax.swing.JComboBox;
  61 import javax.swing.JLabel;
  62 import javax.swing.JPanel;
  63 import javax.swing.JRadioButton;
  64 import javax.swing.JSlider;
  65 import javax.swing.JTabbedPane;
  66 import javax.swing.JTextField;
  67 import javax.swing.SwingConstants;
  68 import javax.swing.border.LineBorder;
  69 import javax.swing.event.ChangeEvent;
  70 import javax.swing.event.ChangeListener;
  71 import javax.swing.plaf.basic.BasicArrowButton;
  72
  73 /**
  74  * A dialog where the user can configure colour scheme, and any filters, for one
  75  * feature type
  76  * <p>
  77  * (Was FeatureColourChooser prior to Jalview 1.11, renamed with the addition of
  78  * filter options)
  79  */
  80 public class FeatureTypeSettings extends JalviewDialog
  81 {
  82   private static final int RADIO_WIDTH = 130;
  83
  84   private static final String COLON = ":";
  85
  86   private static final int MAX_TOOLTIP_LENGTH = 50;
  87
  88   private static final int NO_COLOUR_OPTION = 0;
  89
  90   private static final int MIN_COLOUR_OPTION = 1;
  91
  92   private static final int MAX_COLOUR_OPTION = 2;
  93
  94   private static final int ABOVE_THRESHOLD_OPTION = 1;
  95
  96   private static final int BELOW_THRESHOLD_OPTION = 2;
  97
  98   private static final DecimalFormat DECFMT_2_2 = new DecimalFormat(
  99           "##.##");
 100
 101   /*
 102    * FeatureRenderer holds colour scheme and filters for feature types
 103    */
 104   private final FeatureRenderer fr; // todo refactor to allow interface type here
 105
 106   /*
 107    * the view panel to update when settings change
 108    */
 109   private final AlignmentViewPanel ap;
 110
 111   private final String featureType;
 112
 113   /*
 114    * the colour and filters to reset to on Cancel
 115    */
 116   private final FeatureColourI originalColour;
 117
 118   private final FeatureMatcherSetI originalFilter;
 119
 120   /*
 121    * set flag to true when setting values programmatically,
 122    * to avoid invocation of action handlers
 123    */
 124   private boolean adjusting = false;
 125
 126   /*
 127    * minimum of the value range for graduated colour
 128    * (may be for feature score or for a numeric attribute)
 129    */
 130   private float min;
 131
 132   /*
 133    * maximum of the value range for graduated colour
 134    */
 135   private float max;
 136
 137   /*
 138    * scale factor for conversion between absolute min-max and slider
 139    */
 140   private float scaleFactor;
 141
 142   /*
 143    * radio button group, to select what to colour by:
 144    * simple colour, by category (text), or graduated
 145    */
 146   private JRadioButton simpleColour = new JRadioButton();
 147
 148   private JRadioButton byCategory = new JRadioButton();
 149
 150   private JRadioButton graduatedColour = new JRadioButton();
 151
 152   private JPanel singleColour = new JPanel();
 153
 154   private JPanel minColour = new JPanel();
 155
 156   private JPanel maxColour = new JPanel();
 157
 158   private JComboBox<String> threshold = new JComboBox<>();
 159
 160   private JSlider slider = new JSlider();
 161
 162   private JTextField thresholdValue = new JTextField(20);
 163
 164   private JCheckBox thresholdIsMin = new JCheckBox();
 165
 166   private GraphLine threshline;
 167
 168   private ActionListener featureSettings = null;
 169
 170   private ActionListener changeColourAction;
 171
 172   /*
 173    * choice of option for 'colour for no value'
 174    */
 175   private JComboBox<String> noValueCombo;
 176
 177   /*
 178    * choice of what to colour by text (Label or attribute)
 179    */
 180   private JComboBox<String> colourByTextCombo;
 181
 182   /*
 183    * choice of what to colour by range (Score or attribute)
 184    */
 185   private JComboBox<String> colourByRangeCombo;
 186
 187   private JRadioButton andFilters;
 188
 189   private JRadioButton orFilters;
 190
 191   /*
 192    * filters for the currently selected feature type
 193    */
 194   private List<FeatureMatcherI> filters;
 195
 196   // set white normally, black to debug layout
 197   private Color debugBorderColour = Color.white;
 198
 199   private JPanel chooseFiltersPanel;
 200
 201   private JTabbedPane tabbedPane;
 202
 203   /**
 204    * Constructor
 205    *
 206    * @param frender
 207    * @param theType
 208    */
 209   public FeatureTypeSettings(FeatureRenderer frender, String theType)
 210   {
 211     this(frender, false, theType);
 212   }
 213
 214   /**
 215    * Constructor, with option to make a blocking dialog (has to complete in the
 216    * AWT event queue thread). Currently this option is always set to false.
 217    *
 218    * @param frender
 219    * @param blocking
 220    * @param theType
 221    */
 222   FeatureTypeSettings(FeatureRenderer frender, boolean blocking,
 223           String theType)
 224   {
 225     this.fr = frender;
 226     this.featureType = theType;
 227     ap = fr.ap;
 228     originalFilter = fr.getFeatureFilter(theType);
 229     originalColour = fr.getFeatureColours().get(theType);
 230
 231     adjusting = true;
 232
 233     try
 234     {
 235       initialise();
 236     } catch (Exception ex)
 237     {
 238       ex.printStackTrace();
 239       return;
 240     }
 241
 242     updateColoursTab();
 243
 244     updateFiltersTab();
 245
 246     adjusting = false;
 247
 248     colourChanged(false);
 249
 250     String title = MessageManager
 251             .formatMessage("label.display_settings_for", new String[]
 252             { theType });
 253     initDialogFrame(this, true, blocking, title, 600, 360);
 254
 255     waitForInput();
 256   }
 257
 258   /**
 259    * Configures the widgets on the Colours tab according to the current feature
 260    * colour scheme
 261    */
 262   private void updateColoursTab()
 263   {
 264     FeatureColourI fc = fr.getFeatureColours().get(featureType);
 265
 266     /*
 267      * suppress action handling while updating values programmatically
 268      */
 269     adjusting = true;
 270     try
 271     {
 272       /*
 273        * single colour
 274        */
 275       if (fc.isSimpleColour())
 276       {
 277         simpleColour.setSelected(true);
 278         singleColour.setBackground(fc.getColour());
 279         singleColour.setForeground(fc.getColour());
 280       }
 281
 282       /*
 283        * colour by text (Label or attribute text)
 284        */
 285       if (fc.isColourByLabel())
 286       {
 287         byCategory.setSelected(true);
 288         colourByTextCombo.setEnabled(colourByTextCombo.getItemCount() > 1);
 289         if (fc.isColourByAttribute())
 290         {
 291           String[] attributeName = fc.getAttributeName();
 292           colourByTextCombo
 293                   .setSelectedItem(toAttributeDisplayName(attributeName));
 294         }
 295         else
 296         {
 297           colourByTextCombo
 298                   .setSelectedItem(MessageManager.getString("label.label"));
 299         }
 300       }
 301       else
 302       {
 303         colourByTextCombo.setEnabled(false);
 304       }
 305
 306       if (!fc.isGraduatedColour())
 307       {
 308         colourByRangeCombo.setEnabled(false);
 309         minColour.setEnabled(false);
 310         maxColour.setEnabled(false);
 311         noValueCombo.setEnabled(false);
 312         threshold.setEnabled(false);
 313         slider.setEnabled(false);
 314         thresholdValue.setEnabled(false);
 315         thresholdIsMin.setEnabled(false);
 316         return;
 317       }
 318
 319       /*
 320        * Graduated colour, by score or attribute value range
 321        */
 322       graduatedColour.setSelected(true);
 323       colourByRangeCombo.setEnabled(colourByRangeCombo.getItemCount() > 1);
 324       minColour.setEnabled(true);
 325       maxColour.setEnabled(true);
 326       noValueCombo.setEnabled(true);
 327       threshold.setEnabled(true);
 328       minColour.setBackground(fc.getMinColour());
 329       maxColour.setBackground(fc.getMaxColour());
 330
 331       if (fc.isColourByAttribute())
 332       {
 333         String[] attributeName = fc.getAttributeName();
 334         colourByRangeCombo
 335                 .setSelectedItem(toAttributeDisplayName(attributeName));
 336       }
 337       else
 338       {
 339         colourByRangeCombo
 340                 .setSelectedItem(MessageManager.getString("label.score"));
 341       }
 342       Color noColour = fc.getNoColour();
 343       if (noColour == null)
 344       {
 345         noValueCombo.setSelectedIndex(NO_COLOUR_OPTION);
 346       }
 347       else if (noColour.equals(fc.getMinColour()))
 348       {
 349         noValueCombo.setSelectedIndex(MIN_COLOUR_OPTION);
 350       }
 351       else if (noColour.equals(fc.getMaxColour()))
 352       {
 353         noValueCombo.setSelectedIndex(MAX_COLOUR_OPTION);
 354       }
 355
 356       /*
 357        * update min-max scaling if there is a range to work with,
 358        * else disable the widgets (this shouldn't happen if only
 359        * valid options are offered in the combo box)
 360        */
 361       scaleFactor = (max == min) ? 1f : 100f / (max - min);
 362       float range = (max - min) * scaleFactor;
 363       slider.setMinimum((int) (min * scaleFactor));
 364       slider.setMaximum((int) (max * scaleFactor));
 365       slider.setMajorTickSpacing((int) (range / 10f));
 366
 367       threshline = new GraphLine((max - min) / 2f, "Threshold",
 368               Color.black);
 369       threshline.value = fc.getThreshold();
 370
 371       if (fc.hasThreshold())
 372       {
 373         threshold.setSelectedIndex(
 374                 fc.isAboveThreshold() ? ABOVE_THRESHOLD_OPTION
 375                         : BELOW_THRESHOLD_OPTION);
 376         slider.setEnabled(true);
 377         slider.setValue((int) (fc.getThreshold() * scaleFactor));
 378         thresholdValue.setText(String.valueOf(getRoundedSliderValue()));
 379         thresholdValue.setEnabled(true);
 380         thresholdIsMin.setEnabled(true);
 381       }
 382       else
 383       {
 384         slider.setEnabled(false);
 385         thresholdValue.setEnabled(false);
 386         thresholdIsMin.setEnabled(false);
 387       }
 388       thresholdIsMin.setSelected(!fc.isAutoScaled());
 389     } finally
 390     {
 391       adjusting = false;
 392     }
 393   }
 394
 395   /**
 396    * Configures the initial layout
 397    */
 398   private void initialise()
 399   {
 400     this.setLayout(new BorderLayout());
 401     tabbedPane = new JTabbedPane();
 402     this.add(tabbedPane, BorderLayout.CENTER);
 403
 404     /*
 405      * an ActionListener that applies colour changes
 406      */
 407     changeColourAction = new ActionListener()
 408     {
 409       @Override
 410       public void actionPerformed(ActionEvent e)
 411       {
 412         colourChanged(true);
 413       }
 414     };
 415
 416     /*
 417      * first tab: colour options
 418      */
 419     JPanel coloursPanel = initialiseColoursPanel();
 420     tabbedPane.addTab(MessageManager.getString("action.colour"),
 421             coloursPanel);
 422
 423     /*
 424      * second tab: filter options
 425      */
 426     JPanel filtersPanel = initialiseFiltersPanel();
 427     tabbedPane.addTab(MessageManager.getString("label.filters"),
 428             filtersPanel);
 429
 430     JPanel okCancelPanel = initialiseOkCancelPanel();
 431
 432     this.add(okCancelPanel, BorderLayout.SOUTH);
 433   }
 434
 435   /**
 436    * Updates the min-max range if Colour By selected item is Score, or an
 437    * attribute, with a min-max range
 438    */
 439   protected void updateColourMinMax()
 440   {
 441     if (!graduatedColour.isSelected())
 442     {
 443       return;
 444     }
 445
 446     String colourBy = (String) colourByRangeCombo.getSelectedItem();
 447     String[] attNames = fromAttributeDisplayName(colourBy);
 448     float[] minMax = getMinMax(attNames);
 449
 450     if (minMax != null)
 451     {
 452       min = minMax[0];
 453       max = minMax[1];
 454     }
 455   }
 456
 457   /**
 458    * Retrieves the min-max range:
 459    * <ul>
 460    * <li>of feature score, if colour or filter is by Score</li>
 461    * <li>else of the selected attribute</li>
 462    * </ul>
 463    *
 464    * @param attNames
 465    * @return
 466    */
 467   private float[] getMinMax(String[] attNames)
 468   {
 469     float[] minMax = null;
 470     if (MessageManager.getString("label.score").equals(attNames[0]))
 471     {
 472       minMax = fr.getMinMax().get(featureType)[0];
 473     }
 474     else
 475     {
 476       // colour by attribute range
 477       minMax = FeatureAttributes.getInstance().getMinMax(featureType,
 478               attNames);
 479     }
 480     return minMax;
 481   }
 482
 483   /**
 484    * Lay out fields for graduated colour (by score or attribute value)
 485    *
 486    * @return
 487    */
 488   private JPanel initialiseGraduatedColourPanel()
 489   {
 490     JPanel graduatedColourPanel = new JPanel();
 491     graduatedColourPanel.setLayout(
 492             new BoxLayout(graduatedColourPanel, BoxLayout.Y_AXIS));
 493     JvSwingUtils.createTitledBorder(graduatedColourPanel,
 494             MessageManager.getString("label.graduated_colour"), true);
 495     graduatedColourPanel.setBackground(Color.white);
 496
 497     /*
 498      * first row: graduated colour radio button, score/attribute drop-down
 499      */
 500     JPanel graduatedChoicePanel = new JPanel(
 501             new FlowLayout(FlowLayout.LEFT));
 502     graduatedChoicePanel.setBackground(Color.white);
 503     graduatedColour = new JRadioButton(
 504             MessageManager.getString("label.by_range_of") + COLON);
 505     graduatedColour.setPreferredSize(new Dimension(RADIO_WIDTH, 20));
 506     graduatedColour.addItemListener(new ItemListener()
 507     {
 508       @Override
 509       public void itemStateChanged(ItemEvent e)
 510       {
 511         if (graduatedColour.isSelected())
 512         {
 513           colourChanged(true);
 514         }
 515       }
 516     });
 517     graduatedChoicePanel.add(graduatedColour);
 518
 519     List<String[]> attNames = FeatureAttributes.getInstance()
 520             .getAttributes(featureType);
 521     colourByRangeCombo = populateAttributesDropdown(attNames, true, false);
 522     colourByRangeCombo.addItemListener(new ItemListener()
 523     {
 524       @Override
 525       public void itemStateChanged(ItemEvent e)
 526       {
 527         colourChanged(true);
 528       }
 529     });
 530
 531     /*
 532      * disable graduated colour option if no range found
 533      */
 534     graduatedColour.setEnabled(colourByRangeCombo.getItemCount() > 0);
 535
 536     graduatedChoicePanel.add(colourByRangeCombo);
 537     graduatedColourPanel.add(graduatedChoicePanel);
 538
 539     /*
 540      * second row - min/max/no colours
 541      */
 542     JPanel colourRangePanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
 543     colourRangePanel.setBackground(Color.white);
 544     graduatedColourPanel.add(colourRangePanel);
 545
 546     minColour.setFont(JvSwingUtils.getLabelFont());
 547     minColour.setBorder(BorderFactory.createLineBorder(Color.black));
 548     minColour.setPreferredSize(new Dimension(40, 20));
 549     minColour.setToolTipText(MessageManager.getString("label.min_colour"));
 550     minColour.addMouseListener(new MouseAdapter()
 551     {
 552       @Override
 553       public void mousePressed(MouseEvent e)
 554       {
 555         if (minColour.isEnabled())
 556         {
 557           showColourChooser(minColour, "label.select_colour_minimum_value");
 558         }
 559       }
 560     });
 561
 562     maxColour.setFont(JvSwingUtils.getLabelFont());
 563     maxColour.setBorder(BorderFactory.createLineBorder(Color.black));
 564     maxColour.setPreferredSize(new Dimension(40, 20));
 565     maxColour.setToolTipText(MessageManager.getString("label.max_colour"));
 566     maxColour.addMouseListener(new MouseAdapter()
 567     {
 568       @Override
 569       public void mousePressed(MouseEvent e)
 570       {
 571         if (maxColour.isEnabled())
 572         {
 573           showColourChooser(maxColour, "label.select_colour_maximum_value");
 574         }
 575       }
 576     });
 577     maxColour.setBorder(new LineBorder(Color.black));
 578
 579     /*
 580      * default max colour to current colour (if a plain colour),
 581      * or to Black if colour by label;  make min colour a pale
 582      * version of max colour
 583      */
 584     FeatureColourI fc = fr.getFeatureColours().get(featureType);
 585     Color bg = fc.isSimpleColour() ? fc.getColour() : Color.BLACK;
 586     maxColour.setBackground(bg);
 587     minColour.setBackground(ColorUtils.bleachColour(bg, 0.9f));
 588
 589     noValueCombo = new JComboBox<>();
 590     noValueCombo.addItem(MessageManager.getString("label.no_colour"));
 591     noValueCombo.addItem(MessageManager.getString("label.min_colour"));
 592     noValueCombo.addItem(MessageManager.getString("label.max_colour"));
 593     noValueCombo.addItemListener(new ItemListener()
 594     {
 595       @Override
 596       public void itemStateChanged(ItemEvent e)
 597       {
 598         colourChanged(true);
 599       }
 600     });
 601
 602     JLabel minText = new JLabel(
 603             MessageManager.getString("label.min_value") + COLON);
 604     minText.setFont(JvSwingUtils.getLabelFont());
 605     JLabel maxText = new JLabel(
 606             MessageManager.getString("label.max_value") + COLON);
 607     maxText.setFont(JvSwingUtils.getLabelFont());
 608     JLabel noText = new JLabel(
 609             MessageManager.getString("label.no_value") + COLON);
 610     noText.setFont(JvSwingUtils.getLabelFont());
 611
 612     colourRangePanel.add(minText);
 613     colourRangePanel.add(minColour);
 614     colourRangePanel.add(maxText);
 615     colourRangePanel.add(maxColour);
 616     colourRangePanel.add(noText);
 617     colourRangePanel.add(noValueCombo);
 618
 619     /*
 620      * third row - threshold options and value
 621      */
 622     JPanel thresholdPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
 623     thresholdPanel.setBackground(Color.white);
 624     graduatedColourPanel.add(thresholdPanel);
 625
 626     threshold.addActionListener(changeColourAction);
 627     threshold.setToolTipText(MessageManager
 628             .getString("label.threshold_feature_display_by_score"));
 629     threshold.addItem(MessageManager
 630             .getString("label.threshold_feature_no_threshold")); // index 0
 631     threshold.addItem(MessageManager
 632             .getString("label.threshold_feature_above_threshold")); // index 1
 633     threshold.addItem(MessageManager
 634             .getString("label.threshold_feature_below_threshold")); // index 2
 635
 636     thresholdValue.addActionListener(new ActionListener()
 637     {
 638       @Override
 639       public void actionPerformed(ActionEvent e)
 640       {
 641         thresholdValue_actionPerformed();
 642       }
 643     });
 644     thresholdValue.addFocusListener(new FocusAdapter()
 645     {
 646       @Override
 647       public void focusLost(FocusEvent e)
 648       {
 649         thresholdValue_actionPerformed();
 650       }
 651     });
 652     slider.setPaintLabels(false);
 653     slider.setPaintTicks(true);
 654     slider.setBackground(Color.white);
 655     slider.setEnabled(false);
 656     slider.setOpaque(false);
 657     slider.setPreferredSize(new Dimension(100, 32));
 658     slider.setToolTipText(
 659             MessageManager.getString("label.adjust_threshold"));
 660
 661     slider.addChangeListener(new ChangeListener()
 662     {
 663       @Override
 664       public void stateChanged(ChangeEvent evt)
 665       {
 666         if (!adjusting)
 667         {
 668           thresholdValue
 669                   .setText(String.valueOf(slider.getValue() / scaleFactor));
 670           sliderValueChanged();
 671         }
 672       }
 673     });
 674     slider.addMouseListener(new MouseAdapter()
 675     {
 676       @Override
 677       public void mouseReleased(MouseEvent evt)
 678       {
 679         /*
 680          * only update Overview and/or structure colouring
 681          * when threshold slider drag ends (mouse up)
 682          */
 683         if (ap != null)
 684         {
 685           ap.paintAlignment(true, true);
 686         }
 687       }
 688     });
 689
 690     thresholdValue.setEnabled(false);
 691     thresholdValue.setColumns(7);
 692
 693     thresholdPanel.add(threshold);
 694     thresholdPanel.add(slider);
 695     thresholdPanel.add(thresholdValue);
 696
 697     thresholdIsMin.setBackground(Color.white);
 698     thresholdIsMin
 699             .setText(MessageManager.getString("label.threshold_minmax"));
 700     thresholdIsMin.setToolTipText(MessageManager
 701             .getString("label.toggle_absolute_relative_display_threshold"));
 702     thresholdIsMin.addActionListener(changeColourAction);
 703     thresholdPanel.add(thresholdIsMin);
 704
 705     return graduatedColourPanel;
 706   }
 707
 708   /**
 709    * Lay out OK and Cancel buttons
 710    *
 711    * @return
 712    */
 713   private JPanel initialiseOkCancelPanel()
 714   {
 715     JPanel okCancelPanel = new JPanel();
 716     // okCancelPanel.setBackground(Color.white);
 717     okCancelPanel.add(ok);
 718     okCancelPanel.add(cancel);
 719     return okCancelPanel;
 720   }
 721
 722   /**
 723    * Lay out Colour options panel, containing
 724    * <ul>
 725    * <li>plain colour, with colour picker</li>
 726    * <li>colour by text, with choice of Label or other attribute</li>
 727    * <li>colour by range, of score or other attribute, when available</li>
 728    * </ul>
 729    *
 730    * @return
 731    */
 732   private JPanel initialiseColoursPanel()
 733   {
 734     JPanel colourByPanel = new JPanel();
 735     colourByPanel.setLayout(new BoxLayout(colourByPanel, BoxLayout.Y_AXIS));
 736
 737     /*
 738      * simple colour radio button and colour picker
 739      */
 740     JPanel simpleColourPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
 741     simpleColourPanel.setBackground(Color.white);
 742     JvSwingUtils.createTitledBorder(simpleColourPanel,
 743             MessageManager.getString("label.simple"), true);
 744     colourByPanel.add(simpleColourPanel);
 745
 746     simpleColour = new JRadioButton(
 747             MessageManager.getString("label.simple_colour"));
 748     simpleColour.setPreferredSize(new Dimension(RADIO_WIDTH, 20));
 749     simpleColour.addItemListener(new ItemListener()
 750     {
 751       @Override
 752       public void itemStateChanged(ItemEvent e)
 753       {
 754         if (simpleColour.isSelected() && !adjusting)
 755         {
 756           showColourChooser(singleColour, "label.select_colour");
 757         }
 758       }
 759
 760     });
 761
 762     singleColour.setFont(JvSwingUtils.getLabelFont());
 763     singleColour.setBorder(BorderFactory.createLineBorder(Color.black));
 764     singleColour.setPreferredSize(new Dimension(40, 20));
 765     singleColour.addMouseListener(new MouseAdapter()
 766     {
 767       @Override
 768       public void mousePressed(MouseEvent e)
 769       {
 770         if (simpleColour.isSelected())
 771         {
 772           showColourChooser(singleColour, "label.select_colour");
 773         }
 774       }
 775     });
 776     simpleColourPanel.add(simpleColour); // radio button
 777     simpleColourPanel.add(singleColour); // colour picker button
 778
 779     /*
 780      * colour by text (category) radio button and drop-down choice list
 781      */
 782     JPanel byTextPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
 783     byTextPanel.setBackground(Color.white);
 784     JvSwingUtils.createTitledBorder(byTextPanel,
 785             MessageManager.getString("label.colour_by_text"), true);
 786     colourByPanel.add(byTextPanel);
 787     byCategory = new JRadioButton(
 788             MessageManager.getString("label.by_text_of") + COLON);
 789     byCategory.setPreferredSize(new Dimension(RADIO_WIDTH, 20));
 790     byCategory.addItemListener(new ItemListener()
 791     {
 792       @Override
 793       public void itemStateChanged(ItemEvent e)
 794       {
 795         if (byCategory.isSelected())
 796         {
 797           colourChanged(true);
 798         }
 799       }
 800     });
 801     byTextPanel.add(byCategory);
 802
 803     List<String[]> attNames = FeatureAttributes.getInstance()
 804             .getAttributes(featureType);
 805     colourByTextCombo = populateAttributesDropdown(attNames, false, true);
 806     colourByTextCombo.addItemListener(new ItemListener()
 807     {
 808       @Override
 809       public void itemStateChanged(ItemEvent e)
 810       {
 811         colourChanged(true);
 812       }
 813     });
 814     byTextPanel.add(colourByTextCombo);
 815
 816     /*
 817      * graduated colour panel
 818      */
 819     JPanel graduatedColourPanel = initialiseGraduatedColourPanel();
 820     colourByPanel.add(graduatedColourPanel);
 821
 822     /*
 823      * 3 radio buttons select between simple colour,
 824      * by category (text), or graduated
 825      */
 826     ButtonGroup bg = new ButtonGroup();
 827     bg.add(simpleColour);
 828     bg.add(byCategory);
 829     bg.add(graduatedColour);
 830
 831     return colourByPanel;
 832   }
 833
 834   private void showColourChooser(JPanel colourPanel, String key)
 835   {
 836     Color col = JColorChooser.showDialog(this,
 837             MessageManager.getString(key), colourPanel.getBackground());
 838     if (col != null)
 839     {
 840       colourPanel.setBackground(col);
 841       colourPanel.setForeground(col);
 842     }
 843     colourPanel.repaint();
 844     colourChanged(true);
 845   }
 846
 847   /**
 848    * Constructs and sets the selected colour options as the colour for the feature
 849    * type, and repaints the alignment, and optionally the Overview and/or
 850    * structure viewer if open
 851    *
 852    * @param updateStructsAndOverview
 853    */
 854   void colourChanged(boolean updateStructsAndOverview)
 855   {
 856     if (adjusting)
 857     {
 858       /*
 859        * ignore action handlers while setting values programmatically
 860        */
 861       return;
 862     }
 863
 864     /*
 865      * ensure min-max range is for the latest choice of
 866      * 'graduated colour by'
 867      */
 868     updateColourMinMax();
 869
 870     FeatureColourI acg = makeColourFromInputs();
 871
 872     /*
 873      * save the colour, and repaint stuff
 874      */
 875     fr.setColour(featureType, acg);
 876     ap.paintAlignment(updateStructsAndOverview, updateStructsAndOverview);
 877
 878     updateColoursTab();
 879   }
 880
 881   /**
 882    * Converts the input values into an instance of FeatureColour
 883    *
 884    * @return
 885    */
 886   private FeatureColourI makeColourFromInputs()
 887   {
 888     /*
 889      * easiest case - a single colour
 890      */
 891     if (simpleColour.isSelected())
 892     {
 893       return new FeatureColour(singleColour.getBackground());
 894     }
 895
 896     /*
 897      * next easiest case - colour by Label, or attribute text
 898      */
 899     if (byCategory.isSelected())
 900     {
 901       Color c = this.getBackground();
 902       FeatureColourI fc = new FeatureColour(c, c, null, 0f, 0f);
 903       fc.setColourByLabel(true);
 904       String byWhat = (String) colourByTextCombo.getSelectedItem();
 905       if (!MessageManager.getString("label.label").equals(byWhat))
 906       {
 907         fc.setAttributeName(fromAttributeDisplayName(byWhat));
 908       }
 909       return fc;
 910     }
 911
 912     /*
 913      * remaining case - graduated colour by score, or attribute value
 914      */
 915     Color noColour = null;
 916     if (noValueCombo.getSelectedIndex() == MIN_COLOUR_OPTION)
 917     {
 918       noColour = minColour.getBackground();
 919     }
 920     else if (noValueCombo.getSelectedIndex() == MAX_COLOUR_OPTION)
 921     {
 922       noColour = maxColour.getBackground();
 923     }
 924
 925     float thresh = 0f;
 926     try
 927     {
 928       thresh = Float.valueOf(thresholdValue.getText());
 929     } catch (NumberFormatException e)
 930     {
 931       // invalid inputs are already handled on entry
 932     }
 933
 934     /*
 935      * min-max range is to (or from) threshold value if
 936      * 'threshold is min/max' is selected
 937      */
 938     float minValue = min;
 939     float maxValue = max;
 940     final int thresholdOption = threshold.getSelectedIndex();
 941     if (thresholdIsMin.isSelected()
 942             && thresholdOption == ABOVE_THRESHOLD_OPTION)
 943     {
 944       minValue = thresh;
 945     }
 946     if (thresholdIsMin.isSelected()
 947             && thresholdOption == BELOW_THRESHOLD_OPTION)
 948     {
 949       maxValue = thresh;
 950     }
 951
 952     /*
 953      * make the graduated colour
 954      */
 955     FeatureColourI fc = new FeatureColour(minColour.getBackground(),
 956             maxColour.getBackground(), noColour, minValue, maxValue);
 957
 958     /*
 959      * set attribute to colour by if selected
 960      */
 961     String byWhat = (String) colourByRangeCombo.getSelectedItem();
 962     if (!MessageManager.getString("label.score").equals(byWhat))
 963     {
 964       fc.setAttributeName(fromAttributeDisplayName(byWhat));
 965     }
 966
 967     /*
 968      * set threshold options and 'autoscaled' which is
 969      * false if 'threshold is min/max' is selected
 970      * else true (colour range is on actual range of values)
 971      */
 972     fc.setThreshold(thresh);
 973     fc.setAutoScaled(!thresholdIsMin.isSelected());
 974     fc.setAboveThreshold(thresholdOption == ABOVE_THRESHOLD_OPTION);
 975     fc.setBelowThreshold(thresholdOption == BELOW_THRESHOLD_OPTION);
 976
 977     if (threshline == null)
 978     {
 979       /*
 980        * todo not yet implemented: visual indication of feature threshold
 981        */
 982       threshline = new GraphLine((max - min) / 2f, "Threshold",
 983               Color.black);
 984     }
 985
 986     return fc;
 987   }
 988
 989   /**
 990    * A helper method that converts a 'compound' attribute name from its display
 991    * form, e.g. CSQ:PolyPhen to array form, e.g. { "CSQ", "PolyPhen" }
 992    *
 993    * @param attribute
 994    * @return
 995    */
 996   private String[] fromAttributeDisplayName(String attribute)
 997   {
 998     return attribute == null ? null : attribute.split(COLON);
 999   }
1000
1001   /**
1002    * A helper method that converts a 'compound' attribute name to its display
1003    * form, e.g. CSQ:PolyPhen from its array form, e.g. { "CSQ", "PolyPhen" }
1004    *
1005    * @param attName
1006    * @return
1007    */
1008   private String toAttributeDisplayName(String[] attName)
1009   {
1010     return attName == null ? "" : String.join(COLON, attName);
1011   }
1012
1013   @Override
1014   protected void raiseClosed()
1015   {
1016     if (this.featureSettings != null)
1017     {
1018       featureSettings.actionPerformed(new ActionEvent(this, 0, "CLOSED"));
1019     }
1020   }
1021
1022   /**
1023    * Action on OK is just to dismiss the dialog - any changes have already been
1024    * applied
1025    */
1026   @Override
1027   public void okPressed()
1028   {
1029   }
1030
1031   /**
1032    * Action on Cancel is to restore colour scheme and filters as they were when
1033    * the dialog was opened
1034    */
1035   @Override
1036   public void cancelPressed()
1037   {
1038     fr.setColour(featureType, originalColour);
1039     fr.setFeatureFilter(featureType, originalFilter);
1040     ap.paintAlignment(true, true);
1041   }
1042
1043   /**
1044    * Action on text entry of a threshold value
1045    */
1046   protected void thresholdValue_actionPerformed()
1047   {
1048     try
1049     {
1050       adjusting = true;
1051       float f = Float.parseFloat(thresholdValue.getText());
1052       slider.setValue((int) (f * scaleFactor));
1053       threshline.value = f;
1054       thresholdValue.setBackground(Color.white); // ok
1055
1056       /*
1057        * force repaint of any Overview window or structure
1058        */
1059       ap.paintAlignment(true, true);
1060     } catch (NumberFormatException ex)
1061     {
1062       thresholdValue.setBackground(Color.red); // not ok
1063     } finally
1064     {
1065       adjusting = false;
1066     }
1067   }
1068
1069   /**
1070    * Action on change of threshold slider value. This may be done interactively
1071    * (by moving the slider), or programmatically (to update the slider after
1072    * manual input of a threshold value).
1073    */
1074   protected void sliderValueChanged()
1075   {
1076     threshline.value = getRoundedSliderValue();
1077
1078     /*
1079      * repaint alignment, but not Overview or structure,
1080      * to avoid overload while dragging the slider
1081      */
1082     colourChanged(false);
1083   }
1084
1085   /**
1086    * Converts the slider value to its absolute value by dividing by the
1087    * scaleFactor. Rounding errors are squashed by forcing min/max of slider range
1088    * to the actual min/max of feature score range
1089    *
1090    * @return
1091    */
1092   private float getRoundedSliderValue()
1093   {
1094     int value = slider.getValue();
1095     float f = value == slider.getMaximum() ? max
1096             : (value == slider.getMinimum() ? min : value / scaleFactor);
1097     return f;
1098   }
1099
1100   void addActionListener(ActionListener listener)
1101   {
1102     if (featureSettings != null)
1103     {
1104       System.err.println(
1105               "IMPLEMENTATION ISSUE: overwriting action listener for FeatureColourChooser");
1106     }
1107     featureSettings = listener;
1108   }
1109
1110   /**
1111    * A helper method to build the drop-down choice of attributes for a feature. If
1112    * 'withRange' is true, then Score, and any attributes with a min-max range, are
1113    * added. If 'withText' is true, Label and any known attributes are added. This
1114    * allows 'categorical numerical' attributes e.g. codon position to be coloured
1115    * by text.
1116    * <p>
1117    * Where metadata is available with a description for an attribute, that is
1118    * added as a tooltip.
1119    * <p>
1120    * Attribute names may be 'simple' e.g. "AC" or 'compound' e.g. {"CSQ",
1121    * "Allele"}. Compound names are rendered for display as (e.g.) CSQ:Allele.
1122    * <p>
1123    * This method does not add any ActionListener to the JComboBox.
1124    *
1125    * @param attNames
1126    * @param withRange
1127    * @param withText
1128    */
1129   protected JComboBox<String> populateAttributesDropdown(
1130           List<String[]> attNames, boolean withRange, boolean withText)
1131   {
1132     List<String> displayAtts = new ArrayList<>();
1133     List<String> tooltips = new ArrayList<>();
1134
1135     if (withText)
1136     {
1137       displayAtts.add(MessageManager.getString("label.label"));
1138       tooltips.add(MessageManager.getString("label.description"));
1139     }
1140     if (withRange)
1141     {
1142       float[][] minMax = fr.getMinMax().get(featureType);
1143       if (minMax != null && minMax[0][0] != minMax[0][1])
1144       {
1145         displayAtts.add(MessageManager.getString("label.score"));
1146         tooltips.add(MessageManager.getString("label.score"));
1147       }
1148     }
1149
1150     FeatureAttributes fa = FeatureAttributes.getInstance();
1151     for (String[] attName : attNames)
1152     {
1153       float[] minMax = fa.getMinMax(featureType, attName);
1154       boolean hasRange = minMax != null && minMax[0] != minMax[1];
1155       if (!withText && !hasRange)
1156       {
1157         continue;
1158       }
1159       displayAtts.add(toAttributeDisplayName(attName));
1160       String desc = fa.getDescription(featureType, attName);
1161       if (desc != null && desc.length() > MAX_TOOLTIP_LENGTH)
1162       {
1163         desc = desc.substring(0, MAX_TOOLTIP_LENGTH) + "...";
1164       }
1165       tooltips.add(desc == null ? "" : desc);
1166     }
1167
1168     JComboBox<String> attCombo = JvSwingUtils
1169             .buildComboWithTooltips(displayAtts, tooltips);
1170
1171     return attCombo;
1172   }
1173
1174   /**
1175    * Populates initial layout of the feature attribute filters panel
1176    */
1177   private JPanel initialiseFiltersPanel()
1178   {
1179     filters = new ArrayList<>();
1180
1181     JPanel filtersPanel = new JPanel();
1182     filtersPanel.setLayout(new BoxLayout(filtersPanel, BoxLayout.Y_AXIS));
1183     filtersPanel.setBackground(Color.white);
1184     JvSwingUtils.createTitledBorder(filtersPanel,
1185             MessageManager.getString("label.filters"), true);
1186
1187     JPanel andOrPanel = initialiseAndOrPanel();
1188     filtersPanel.add(andOrPanel);
1189
1190     /*
1191      * panel with filters - populated by refreshFiltersDisplay
1192      */
1193     chooseFiltersPanel = new JPanel();
1194     LayoutManager box = new BoxLayout(chooseFiltersPanel, BoxLayout.Y_AXIS);
1195     chooseFiltersPanel.setLayout(box);
1196     filtersPanel.add(chooseFiltersPanel);
1197
1198     return filtersPanel;
1199   }
1200
1201   /**
1202    * Lays out the panel with radio buttons to AND or OR filter conditions
1203    *
1204    * @return
1205    */
1206   private JPanel initialiseAndOrPanel()
1207   {
1208     JPanel andOrPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
1209     andOrPanel.setBackground(Color.white);
1210     andOrPanel.setBorder(BorderFactory.createLineBorder(debugBorderColour));
1211     andFilters = new JRadioButton(MessageManager.getString("label.and"));
1212     orFilters = new JRadioButton(MessageManager.getString("label.or"));
1213     ActionListener actionListener = new ActionListener()
1214     {
1215       @Override
1216       public void actionPerformed(ActionEvent e)
1217       {
1218         filtersChanged();
1219       }
1220     };
1221     andFilters.addActionListener(actionListener);
1222     orFilters.addActionListener(actionListener);
1223     ButtonGroup andOr = new ButtonGroup();
1224     andOr.add(andFilters);
1225     andOr.add(orFilters);
1226     andFilters.setSelected(true);
1227     andOrPanel.add(
1228             new JLabel(MessageManager.getString("label.join_conditions")));
1229     andOrPanel.add(andFilters);
1230     andOrPanel.add(orFilters);
1231     return andOrPanel;
1232   }
1233
1234   /**
1235    * Refreshes the display to show any filters currently configured for the
1236    * selected feature type (editable, with 'remove' option), plus one extra row
1237    * for adding a condition. This should be called after a filter has been
1238    * removed, added or amended.
1239    */
1240   private void updateFiltersTab()
1241   {
1242     /*
1243      * clear the panel and list of filter conditions
1244      */
1245     chooseFiltersPanel.removeAll();
1246     filters.clear();
1247
1248     /*
1249      * look up attributes known for feature type
1250      */
1251     List<String[]> attNames = FeatureAttributes.getInstance()
1252             .getAttributes(featureType);
1253
1254     /*
1255      * if this feature type has filters set, load them first
1256      */
1257     FeatureMatcherSetI featureFilters = fr.getFeatureFilter(featureType);
1258     if (featureFilters != null)
1259     {
1260       if (!featureFilters.isAnded())
1261       {
1262         orFilters.setSelected(true);
1263       }
1264       featureFilters.getMatchers().forEach(matcher -> filters.add(matcher));
1265     }
1266
1267     /*
1268      * and an empty filter for the user to populate (add)
1269      */
1270     FeatureMatcherI noFilter = FeatureMatcher.byLabel(Condition.values()[0],
1271             "");
1272     filters.add(noFilter);
1273
1274     /*
1275      * render the conditions in rows, each in its own JPanel
1276      */
1277     int filterIndex = 0;
1278     for (FeatureMatcherI filter : filters)
1279     {
1280       String[] attName = filter.getKey();
1281       Condition condition = filter.getMatcher().getCondition();
1282       String pattern = filter.getMatcher().getPattern();
1283       JPanel row = addFilter(attName, attNames, condition, pattern,
1284               filterIndex);
1285       row.setBorder(BorderFactory.createLineBorder(debugBorderColour));
1286       chooseFiltersPanel.add(row);
1287       filterIndex++;
1288     }
1289
1290     this.validate();
1291     this.repaint();
1292   }
1293
1294   /**
1295    * A helper method that constructs a row (panel) with one filter condition:
1296    * <ul>
1297    * <li>a drop-down list of attribute names to choose from</li>
1298    * <li>a drop-down list of conditions to choose from</li>
1299    * <li>a text field for input of a match pattern</li>
1300    * <li>optionally, a 'remove' button</li>
1301    * </ul>
1302    * If attribute, condition or pattern are not null, they are set as defaults for
1303    * the input fields. The 'remove' button is added unless the pattern is null or
1304    * empty (incomplete filter condition).
1305    *
1306    * @param attName
1307    * @param attNames
1308    * @param cond
1309    * @param pattern
1310    * @param filterIndex
1311    * @return
1312    */
1313   protected JPanel addFilter(String[] attName, List<String[]> attNames,
1314           Condition cond, String pattern, int filterIndex)
1315   {
1316     JPanel filterRow = new JPanel(new FlowLayout(FlowLayout.LEFT));
1317     filterRow.setBackground(Color.white);
1318
1319     /*
1320      * drop-down choice of attribute, with description as a tooltip
1321      * if we can obtain it
1322      */
1323     final JComboBox<String> attCombo = populateAttributesDropdown(attNames,
1324             true, true);
1325     JComboBox<Condition> condCombo = new JComboBox<>();
1326     JTextField patternField = new JTextField(8);
1327
1328     /*
1329      * action handlers that validate and (if valid) apply changes
1330      */
1331     ActionListener actionListener = new ActionListener()
1332     {
1333       @Override
1334       public void actionPerformed(ActionEvent e)
1335       {
1336         if (validateFilter(patternField, condCombo))
1337         {
1338           if (updateFilter(attCombo, condCombo, patternField, filterIndex))
1339           {
1340             filtersChanged();
1341           }
1342         }
1343       }
1344     };
1345     ItemListener itemListener = new ItemListener()
1346     {
1347       @Override
1348       public void itemStateChanged(ItemEvent e)
1349       {
1350         actionListener.actionPerformed(null);
1351       }
1352     };
1353
1354     if (attName == null) // the 'add a condition' row
1355     {
1356       attCombo.setSelectedIndex(0);
1357     }
1358     else
1359     {
1360       attCombo.setSelectedItem(toAttributeDisplayName(attName));
1361     }
1362     attCombo.addItemListener(new ItemListener()
1363     {
1364       @Override
1365       public void itemStateChanged(ItemEvent e)
1366       {
1367         /*
1368          * on change of attribute, refresh the conditions list to
1369          * ensure it is appropriate for the attribute datatype
1370          */
1371         populateConditions((String) attCombo.getSelectedItem(),
1372                 (Condition) condCombo.getSelectedItem(), condCombo);
1373         actionListener.actionPerformed(null);
1374       }
1375     });
1376
1377     filterRow.add(attCombo);
1378
1379     /*
1380      * drop-down choice of test condition
1381      */
1382     populateConditions((String) attCombo.getSelectedItem(), cond,
1383             condCombo);
1384     condCombo.setPreferredSize(new Dimension(150, 20));
1385     condCombo.addItemListener(itemListener);
1386     filterRow.add(condCombo);
1387
1388     /*
1389      * pattern to match against
1390      */
1391     patternField.setText(pattern);
1392     patternField.addActionListener(actionListener);
1393     patternField.addFocusListener(new FocusAdapter()
1394     {
1395       @Override
1396       public void focusLost(FocusEvent e)
1397       {
1398         actionListener.actionPerformed(null);
1399       }
1400     });
1401     filterRow.add(patternField);
1402
1403     /*
1404      * disable pattern field for condition 'Present / NotPresent'
1405      */
1406     Condition selectedCondition = (Condition) condCombo.getSelectedItem();
1407     if (!selectedCondition.needsAPattern())
1408     {
1409       patternField.setEnabled(false);
1410     }
1411
1412     /*
1413      * if a numeric condition is selected, show the value range
1414      * as a tooltip on the value input field
1415      */
1416     updatePatternTooltip(attName, selectedCondition, patternField);
1417
1418     /*
1419      * add remove button if filter is populated (non-empty pattern)
1420      */
1421     if (!patternField.isEnabled()
1422             || (pattern != null && pattern.trim().length() > 0))
1423     {
1424       // todo: gif for button drawing '-' or 'x'
1425       JButton removeCondition = new BasicArrowButton(SwingConstants.WEST);
1426       removeCondition
1427               .setToolTipText(MessageManager.getString("label.delete_row"));
1428       removeCondition.addActionListener(new ActionListener()
1429       {
1430         @Override
1431         public void actionPerformed(ActionEvent e)
1432         {
1433           filters.remove(filterIndex);
1434           filtersChanged();
1435         }
1436       });
1437       filterRow.add(removeCondition);
1438     }
1439
1440     return filterRow;
1441   }
1442
1443   /**
1444    * If a numeric comparison condition is selected, retrieve the min-max range for
1445    * the value (score or attribute), and set it as a tooltip on the value file
1446    *
1447    * @param attName
1448    * @param selectedCondition
1449    * @param patternField
1450    */
1451   private void updatePatternTooltip(String[] attName,
1452           Condition selectedCondition, JTextField patternField)
1453   {
1454     patternField.setToolTipText("");
1455
1456     if (selectedCondition.isNumeric())
1457     {
1458       float[] minMax = getMinMax(attName);
1459       if (minMax != null)
1460       {
1461         String tip = String.format("(%s - %s)",
1462                 DECFMT_2_2.format(minMax[0]), DECFMT_2_2.format(minMax[1]));
1463         patternField.setToolTipText(tip);
1464       }
1465     }
1466   }
1467
1468   /**
1469    * Populates the drop-down list of comparison conditions for the given attribute
1470    * name. The conditions added depend on the datatype of the attribute values.
1471    * The supplied condition is set as the selected item in the list, provided it
1472    * is in the list.
1473    *
1474    * @param attName
1475    * @param cond
1476    * @param condCombo
1477    */
1478   private void populateConditions(String attName, Condition cond,
1479           JComboBox<Condition> condCombo)
1480   {
1481     Datatype type = FeatureAttributes.getInstance().getDatatype(featureType,
1482             fromAttributeDisplayName(attName));
1483     if (MessageManager.getString("label.label").equals(attName))
1484     {
1485       type = Datatype.Character;
1486     }
1487     else if (MessageManager.getString("label.score").equals(attName))
1488     {
1489       type = Datatype.Number;
1490     }
1491
1492     /*
1493      * remove itemListener before starting
1494      */
1495     ItemListener listener = condCombo.getItemListeners()[0];
1496     condCombo.removeItemListener(listener);
1497     boolean condIsValid = false;
1498     condCombo.removeAllItems();
1499     for (Condition c : Condition.values())
1500     {
1501       if ((c.isNumeric() && type != Datatype.Character)
1502               || (!c.isNumeric() && type != Datatype.Number))
1503       {
1504         condCombo.addItem(c);
1505         if (c == cond)
1506         {
1507           condIsValid = true;
1508         }
1509       }
1510     }
1511
1512     /*
1513      * set the selected condition (does nothing if not in the list)
1514      */
1515     if (condIsValid)
1516     {
1517       condCombo.setSelectedItem(cond);
1518     }
1519     else
1520     {
1521       condCombo.setSelectedIndex(0);
1522     }
1523
1524     condCombo.addItemListener(listener);
1525   }
1526
1527   /**
1528    * Answers true unless a numeric condition has been selected with a non-numeric
1529    * value. Sets the value field to RED with a tooltip if in error.
1530    * <p>
1531    * If the pattern is expected but is empty, this method returns false, but does
1532    * not mark the field as invalid. This supports selecting an attribute for a new
1533    * condition before a match pattern has been entered.
1534    *
1535    * @param value
1536    * @param condCombo
1537    */
1538   protected boolean validateFilter(JTextField value,
1539           JComboBox<Condition> condCombo)
1540   {
1541     if (value == null || condCombo == null)
1542     {
1543       return true; // fields not populated
1544     }
1545
1546     Condition cond = (Condition) condCombo.getSelectedItem();
1547     if (cond.needsAPattern())
1548     {
1549       return true;
1550     }
1551
1552     value.setBackground(Color.white);
1553     value.setToolTipText("");
1554     String v1 = value.getText().trim();
1555     if (v1.length() == 0)
1556     {
1557       // return false;
1558     }
1559
1560     if (cond.isNumeric() && v1.length() > 0)
1561     {
1562       try
1563       {
1564         Float.valueOf(v1);
1565       } catch (NumberFormatException e)
1566       {
1567         value.setBackground(Color.red);
1568         value.setToolTipText(
1569                 MessageManager.getString("label.numeric_required"));
1570         return false;
1571       }
1572     }
1573
1574     return true;
1575   }
1576
1577   /**
1578    * Constructs a filter condition from the given input fields, and replaces the
1579    * condition at filterIndex with the new one. Does nothing if the pattern field
1580    * is blank (unless the match condition is one that doesn't require a pattern,
1581    * e.g. 'Is present'). Answers true if the filter was updated, else false.
1582    * <p>
1583    * This method may update the tooltip on the filter value field to show the
1584    * value range, if a numeric condition is selected. This ensures the tooltip is
1585    * updated when a numeric valued attribute is chosen on the last 'add a filter'
1586    * row.
1587    *
1588    * @param attCombo
1589    * @param condCombo
1590    * @param valueField
1591    * @param filterIndex
1592    */
1593   protected boolean updateFilter(JComboBox<String> attCombo,
1594           JComboBox<Condition> condCombo, JTextField valueField,
1595           int filterIndex)
1596   {
1597     String attName = (String) attCombo.getSelectedItem();
1598     Condition cond = (Condition) condCombo.getSelectedItem();
1599     String pattern = valueField.getText().trim();
1600
1601     updatePatternTooltip(fromAttributeDisplayName(attName), cond,
1602             valueField);
1603
1604     if (pattern.length() == 0 && cond.needsAPattern())
1605     {
1606       return false;
1607     }
1608
1609     /*
1610      * Construct a matcher that operates on Label, Score,
1611      * or named attribute
1612      */
1613     FeatureMatcherI km = null;
1614     if (MessageManager.getString("label.label").equals(attName))
1615     {
1616       km = FeatureMatcher.byLabel(cond, pattern);
1617     }
1618     else if (MessageManager.getString("label.score").equals(attName))
1619     {
1620       km = FeatureMatcher.byScore(cond, pattern);
1621     }
1622     else
1623     {
1624       km = FeatureMatcher.byAttribute(cond, pattern,
1625               fromAttributeDisplayName(attName));
1626     }
1627
1628     filters.set(filterIndex, km);
1629
1630     return true;
1631   }
1632
1633   /**
1634    * Makes the dialog visible, at the Feature Colour tab or at the Filters tab
1635    *
1636    * @param coloursTab
1637    */
1638   public void showTab(boolean coloursTab)
1639   {
1640     setVisible(true);
1641     tabbedPane.setSelectedIndex(coloursTab ? 0 : 1);
1642   }
1643
1644   /**
1645    * Action on any change to feature filtering, namely
1646    * <ul>
1647    * <li>change of selected attribute</li>
1648    * <li>change of selected condition</li>
1649    * <li>change of match pattern</li>
1650    * <li>removal of a condition</li>
1651    * </ul>
1652    * The inputs are parsed into a combined filter and this is set for the feature
1653    * type, and the alignment redrawn.
1654    */
1655   protected void filtersChanged()
1656   {
1657     /*
1658      * update the filter conditions for the feature type
1659      */
1660     boolean anded = andFilters.isSelected();
1661     FeatureMatcherSetI combined = new FeatureMatcherSet();
1662
1663     for (FeatureMatcherI filter : filters)
1664     {
1665       String pattern = filter.getMatcher().getPattern();
1666       Condition condition = filter.getMatcher().getCondition();
1667       if (pattern.trim().length() > 0 || !condition.needsAPattern())
1668       {
1669         if (anded)
1670         {
1671           combined.and(filter);
1672         }
1673         else
1674         {
1675           combined.or(filter);
1676         }
1677       }
1678     }
1679
1680     /*
1681      * save the filter conditions in the FeatureRenderer
1682      * (note this might now be an empty filter with no conditions)
1683      */
1684     fr.setFeatureFilter(featureType, combined.isEmpty() ? null : combined);
1685     ap.paintAlignment(true, true);
1686
1687     updateFiltersTab();
1688   }
1689 }