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