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