src/jalview/gui/FeatureTypeSettings.java

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