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