src/jalview/gui/FeatureSettings.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.FeatureColourI;
  25 import jalview.api.FeatureSettingsControllerI;
  26 import jalview.api.ViewStyleI;
  27 import jalview.datamodel.AlignmentI;
  28 import jalview.datamodel.SequenceI;
  29 import jalview.datamodel.features.FeatureMatcherI;
  30 import jalview.datamodel.features.FeatureMatcherSet;
  31 import jalview.datamodel.features.FeatureMatcherSetI;
  32 import jalview.datamodel.ontology.OntologyI;
  33 import jalview.gui.Help.HelpId;
  34 import jalview.io.JalviewFileChooser;
  35 import jalview.io.JalviewFileView;
  36 import jalview.io.gff.SequenceOntologyFactory;
  37 import jalview.schemes.FeatureColour;
  38 import jalview.util.MessageManager;
  39 import jalview.util.Platform;
  40 import jalview.viewmodel.seqfeatures.FeatureRendererModel.FeatureSettingsBean;
  41 import jalview.viewmodel.styles.ViewStyle;
  42 import jalview.xml.binding.jalview.JalviewUserColours;
  43 import jalview.xml.binding.jalview.JalviewUserColours.Colour;
  44 import jalview.xml.binding.jalview.JalviewUserColours.Filter;
  45 import jalview.xml.binding.jalview.ObjectFactory;
  46
  47 import java.awt.BorderLayout;
  48 import java.awt.Color;
  49 import java.awt.Component;
  50 import java.awt.Dimension;
  51 import java.awt.FlowLayout;
  52 import java.awt.Font;
  53 import java.awt.Graphics;
  54 import java.awt.GridLayout;
  55 import java.awt.Point;
  56 import java.awt.Rectangle;
  57 import java.awt.event.ActionEvent;
  58 import java.awt.event.ActionListener;
  59 import java.awt.event.ItemEvent;
  60 import java.awt.event.ItemListener;
  61 import java.awt.event.MouseAdapter;
  62 import java.awt.event.MouseEvent;
  63 import java.awt.event.MouseMotionAdapter;
  64 import java.beans.PropertyChangeEvent;
  65 import java.beans.PropertyChangeListener;
  66 import java.io.File;
  67 import java.io.FileInputStream;
  68 import java.io.FileOutputStream;
  69 import java.io.InputStreamReader;
  70 import java.io.OutputStreamWriter;
  71 import java.io.PrintWriter;
  72 import java.util.ArrayList;
  73 import java.util.Arrays;
  74 import java.util.Comparator;
  75 import java.util.HashMap;
  76 import java.util.HashSet;
  77 import java.util.Hashtable;
  78 import java.util.Iterator;
  79 import java.util.List;
  80 import java.util.Map;
  81 import java.util.Set;
  82
  83 import javax.help.HelpSetException;
  84 import javax.swing.AbstractCellEditor;
  85 import javax.swing.BorderFactory;
  86 import javax.swing.Icon;
  87 import javax.swing.JButton;
  88 import javax.swing.JCheckBox;
  89 import javax.swing.JCheckBoxMenuItem;
  90 import javax.swing.JColorChooser;
  91 import javax.swing.JDialog;
  92 import javax.swing.JInternalFrame;
  93 import javax.swing.JLabel;
  94 import javax.swing.JLayeredPane;
  95 import javax.swing.JMenuItem;
  96 import javax.swing.JPanel;
  97 import javax.swing.JPopupMenu;
  98 import javax.swing.JScrollPane;
  99 import javax.swing.JSlider;
 100 import javax.swing.JTable;
 101 import javax.swing.ListSelectionModel;
 102 import javax.swing.RowFilter;
 103 import javax.swing.SwingConstants;
 104 import javax.swing.event.ChangeEvent;
 105 import javax.swing.event.ChangeListener;
 106 import javax.swing.table.AbstractTableModel;
 107 import javax.swing.table.TableCellEditor;
 108 import javax.swing.table.TableCellRenderer;
 109 import javax.swing.table.TableColumn;
 110 import javax.swing.table.TableRowSorter;
 111 import javax.xml.bind.JAXBContext;
 112 import javax.xml.bind.JAXBElement;
 113 import javax.xml.bind.Marshaller;
 114 import javax.xml.stream.XMLInputFactory;
 115 import javax.xml.stream.XMLStreamReader;
 116
 117 public class FeatureSettings extends JPanel
 118         implements FeatureSettingsControllerI
 119 {
 120   private static final Font VERDANA_12 = new Font("Verdana", Font.PLAIN, 12);
 121
 122   private static final String SEQUENCE_FEATURE_COLOURS = MessageManager
 123           .getString("label.sequence_feature_colours");
 124
 125   /*
 126    * column indices of fields in Feature Settings table
 127    */
 128   static final int TYPE_COLUMN = 0;
 129
 130   static final int COLOUR_COLUMN = 1;
 131
 132   static final int FILTER_COLUMN = 2;
 133
 134   static final int SHOW_COLUMN = 3;
 135
 136   private static final int COLUMN_COUNT = 4;
 137
 138   private static final int MIN_WIDTH = 400;
 139
 140   private static final int MIN_HEIGHT = 400;
 141
 142   final FeatureRenderer fr;
 143
 144   public final AlignFrame af;
 145
 146   /*
 147    * 'original' fields hold settings to restore on Cancel
 148    */
 149   Object[][] originalData;
 150
 151   private float originalTransparency;
 152
 153   private ViewStyleI originalViewStyle;
 154
 155   private Map<String, FeatureMatcherSetI> originalFilters;
 156
 157   final JInternalFrame frame;
 158
 159   JScrollPane scrollPane = new JScrollPane();
 160
 161   JTable table;
 162
 163   JPanel groupPanel;
 164
 165   JSlider transparency = new JSlider();
 166
 167   JCheckBox showComplement;
 168
 169   JCheckBox showComplementOnTop;
 170
 171   /*
 172    * when true, constructor is still executing - so ignore UI events
 173    */
 174   protected volatile boolean inConstruction = true;
 175
 176   int selectedRow = -1;
 177
 178   boolean resettingTable = false;
 179
 180   /*
 181    * true when Feature Settings are updating from feature renderer
 182    */
 183   private boolean handlingUpdate = false;
 184
 185   /*
 186    * holds {featureCount, totalExtent} for each feature type
 187    */
 188   Map<String, float[]> typeWidth = null;
 189
 190   /*
 191    * if true, 'child' feature types are not displayed
 192    */
 193   JCheckBox summaryView;
 194
 195   /*
 196    * those feature types that do not have a parent feature type present
 197    * (as determined by an Ontology relationship)
 198    */
 199   List<String> topLevelTypes;
 200
 201   /**
 202    * Constructor
 203    *
 204    * @param af
 205    */
 206   public FeatureSettings(AlignFrame alignFrame)
 207   {
 208     this.af = alignFrame;
 209     fr = af.getFeatureRenderer();
 210
 211     // save transparency for restore on Cancel
 212     originalTransparency = fr.getTransparency();
 213     int originalTransparencyAsPercent = (int) (originalTransparency * 100);
 214     transparency.setMaximum(100 - originalTransparencyAsPercent);
 215
 216     originalFilters = new HashMap<>(fr.getFeatureFilters()); // shallow copy
 217     originalViewStyle = new ViewStyle(af.viewport.getViewStyle());
 218
 219     topLevelTypes = new ArrayList<>();
 220
 221     try
 222     {
 223       jbInit();
 224     } catch (Exception ex)
 225     {
 226       ex.printStackTrace();
 227     }
 228
 229     initTable();
 230
 231     scrollPane.setViewportView(table);
 232
 233     if (af.getViewport().isShowSequenceFeatures() || !fr.hasRenderOrder())
 234     {
 235       fr.findAllFeatures(true); // display everything!
 236     }
 237
 238     discoverAllFeatureData();
 239     final PropertyChangeListener change;
 240     final FeatureSettings fs = this;
 241     fr.addPropertyChangeListener(change = new PropertyChangeListener()
 242     {
 243       @Override
 244       public void propertyChange(PropertyChangeEvent evt)
 245       {
 246         if (!fs.resettingTable && !fs.handlingUpdate)
 247         {
 248           fs.handlingUpdate = true;
 249           fs.resetTable(null);
 250           // new groups may be added with new sequence feature types only
 251           fs.handlingUpdate = false;
 252         }
 253       }
 254     });
 255
 256     frame = new JInternalFrame();
 257     frame.setContentPane(this);
 258     if (Platform.isAMac())
 259     {
 260       Desktop.addInternalFrame(frame,
 261               MessageManager.getString("label.sequence_feature_settings"),
 262               600, 480);
 263     }
 264     else
 265     {
 266       Desktop.addInternalFrame(frame,
 267               MessageManager.getString("label.sequence_feature_settings"),
 268               600, 450);
 269     }
 270     frame.setMinimumSize(new Dimension(MIN_WIDTH, MIN_HEIGHT));
 271
 272     frame.addInternalFrameListener(
 273             new javax.swing.event.InternalFrameAdapter()
 274             {
 275               @Override
 276               public void internalFrameClosed(
 277                       javax.swing.event.InternalFrameEvent evt)
 278               {
 279                 fr.removePropertyChangeListener(change);
 280               };
 281             });
 282     frame.setLayer(JLayeredPane.PALETTE_LAYER);
 283     inConstruction = false;
 284   }
 285
 286   /**
 287    * Constructs and configures the JTable which displays columns of data for
 288    * each feature type
 289    */
 290   protected void initTable()
 291   {
 292     table = new JTable()
 293     {
 294       @Override
 295       public String getToolTipText(MouseEvent e)
 296       {
 297         String tip = null;
 298         int column = table.columnAtPoint(e.getPoint());
 299         switch (column)
 300         {
 301         case TYPE_COLUMN:
 302           /*
 303            * drag to reorder not enabled in Summary View
 304            */
 305           tip = summaryView.isSelected()
 306                   ? MessageManager.getString(
 307                           "label.feature_settings_select_columns")
 308                   : JvSwingUtils.wrapTooltip(true, MessageManager
 309                   .getString("label.feature_settings_click_drag"));
 310           break;
 311         case FILTER_COLUMN:
 312           int row = table.rowAtPoint(e.getPoint());
 313           FeatureMatcherSet o = (FeatureMatcherSet) table.getValueAt(row,
 314                   column);
 315           tip = o.isEmpty()
 316                   ? MessageManager
 317                           .getString("label.configure_feature_tooltip")
 318                   : o.toString();
 319           break;
 320         default:
 321           break;
 322         }
 323         return tip;
 324       }
 325     };
 326     table.getTableHeader().setFont(VERDANA_12);
 327     table.setFont(VERDANA_12);
 328
 329     table.setDefaultEditor(FeatureColour.class, new ColorEditor(this));
 330     table.setDefaultRenderer(FeatureColour.class, new ColorRenderer());
 331
 332     table.setDefaultEditor(FeatureMatcherSet.class, new FilterEditor(this));
 333     table.setDefaultRenderer(FeatureMatcherSet.class, new FilterRenderer());
 334
 335     TableColumn colourColumn = new TableColumn(COLOUR_COLUMN, 75,
 336             new ColorRenderer(), new ColorEditor(this));
 337     table.addColumn(colourColumn);
 338
 339     TableColumn filterColumn = new TableColumn(FILTER_COLUMN, 75,
 340             new FilterRenderer(), new FilterEditor(this));
 341     table.addColumn(filterColumn);
 342
 343     table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 344
 345     table.addMouseListener(new MouseAdapter()
 346     {
 347       @Override
 348       public void mousePressed(MouseEvent evt)
 349       {
 350         selectedRow = table.rowAtPoint(evt.getPoint());
 351         String type = (String) table.getValueAt(selectedRow, TYPE_COLUMN);
 352         if (evt.isPopupTrigger())
 353         {
 354           Object colour = table.getValueAt(selectedRow, COLOUR_COLUMN);
 355           popupMenu(selectedRow, type, colour, evt.getX(), evt.getY());
 356         }
 357         else if (evt.getClickCount() == 2)
 358         {
 359           boolean invertSelection = evt.isAltDown();
 360           boolean toggleSelection = Platform.isControlDown(evt);
 361           boolean extendSelection = evt.isShiftDown();
 362           String[] terms = getTermsInScope(type);
 363           fr.ap.alignFrame.avc.markColumnsContainingFeatures(
 364                   invertSelection, extendSelection, toggleSelection, terms);
 365         }
 366       }
 367
 368       // isPopupTrigger fires on mouseReleased on Windows
 369       @Override
 370       public void mouseReleased(MouseEvent evt)
 371       {
 372         selectedRow = table.rowAtPoint(evt.getPoint());
 373         if (evt.isPopupTrigger())
 374         {
 375           String type = (String) table.getValueAt(selectedRow, TYPE_COLUMN);
 376           Object colour = table.getValueAt(selectedRow, COLOUR_COLUMN);
 377           popupMenu(selectedRow, type, colour, evt.getX(), evt.getY());
 378         }
 379       }
 380     });
 381
 382     table.addMouseMotionListener(new MouseMotionAdapter()
 383     {
 384       @Override
 385       public void mouseDragged(MouseEvent evt)
 386       {
 387         int newRow = table.rowAtPoint(evt.getPoint());
 388         dragRow(newRow);
 389       }
 390     });
 391   }
 392
 393   /**
 394    * Answers an array consisting of the given type, and also (if 'Summary View'
 395    * is selected), any child terms in the sequence ontology
 396    *
 397    * @param type
 398    * @return
 399    */
 400   protected String[] getTermsInScope(String type)
 401   {
 402     if (!summaryView.isSelected())
 403     {
 404       return new String[] { type };
 405     }
 406
 407     List<String> terms = new ArrayList<>();
 408     terms.add(type);
 409
 410     OntologyI so = SequenceOntologyFactory.getInstance();
 411
 412     Object[][] data = ((FeatureTableModel) table.getModel()).getData();
 413     for (Object[] row : data)
 414     {
 415       String type2 = (String) row[TYPE_COLUMN];
 416       if (!type2.equals(type) && so.isA(type2, type))
 417       {
 418         terms.add(type2);
 419       }
 420     }
 421     return terms.toArray(new String[terms.size()]);
 422   }
 423
 424   protected void popupMenu(final int rowSelected, final String type,
 425           final Object typeCol, int x, int y)
 426   {
 427     final FeatureColourI featureColour = (FeatureColourI) typeCol;
 428
 429     JPopupMenu men = new JPopupMenu(MessageManager
 430             .formatMessage("label.settings_for_param", new String[]
 431             { type }));
 432     JMenuItem scr = new JMenuItem(
 433             MessageManager.getString("label.sort_by_score"));
 434     men.add(scr);
 435     final FeatureSettings me = this;
 436     scr.addActionListener(new ActionListener()
 437     {
 438       @Override
 439       public void actionPerformed(ActionEvent e)
 440       {
 441         String[] types = getTermsInScope(type);
 442         me.af.avc.sortAlignmentByFeatureScore(Arrays.asList(types));
 443       }
 444     });
 445     JMenuItem dens = new JMenuItem(
 446             MessageManager.getString("label.sort_by_density"));
 447     dens.addActionListener(new ActionListener()
 448     {
 449       @Override
 450       public void actionPerformed(ActionEvent e)
 451       {
 452         String[] types = getTermsInScope(type);
 453         me.af.avc.sortAlignmentByFeatureDensity(Arrays.asList(types));
 454       }
 455     });
 456     men.add(dens);
 457
 458     // fixme is Variable Colour in popup menu or not
 459     /*
 460      * variable colour options include colour by label, by score,
 461      * by selected attribute text, or attribute value
 462      */
 463     final JCheckBoxMenuItem mxcol = new JCheckBoxMenuItem(
 464             MessageManager.getString("label.variable_colour"));
 465     mxcol.setSelected(!featureColour.isSimpleColour());
 466     men.add(mxcol);
 467     mxcol.addActionListener(new ActionListener()
 468     {
 469       JColorChooser colorChooser;
 470
 471       @Override
 472       public void actionPerformed(ActionEvent e)
 473       {
 474         if (e.getSource() == mxcol)
 475         {
 476           if (featureColour.isSimpleColour())
 477           {
 478             FeatureTypeSettings fc = new FeatureTypeSettings(me.fr, type);
 479             fc.addActionListener(this);
 480           }
 481           else
 482           {
 483             // bring up simple color chooser
 484             colorChooser = new JColorChooser();
 485             String title = MessageManager
 486                     .getString("label.select_colour");
 487             JDialog dialog = JColorChooser.createDialog(me,
 488                     title, true, // modal
 489                     colorChooser, this, // OK button handler
 490                     null); // no CANCEL button handler
 491             colorChooser.setColor(featureColour.getMaxColour());
 492             dialog.setVisible(true);
 493           }
 494         }
 495         else
 496         {
 497           if (e.getSource() instanceof FeatureTypeSettings)
 498           {
 499             /*
 500              * update after OK in feature colour dialog; the updated
 501              * colour will have already been set in the FeatureRenderer
 502              */
 503             FeatureColourI fci = fr.getFeatureColours().get(type);
 504             table.setValueAt(fci, rowSelected, 1);
 505             table.validate();
 506           }
 507           else
 508           {
 509             // probably the color chooser!
 510             table.setValueAt(new FeatureColour(colorChooser.getColor()),
 511                     rowSelected, 1);
 512             table.validate();
 513             me.updateFeatureRenderer(
 514                     ((FeatureTableModel) table.getModel()).getData(),
 515                     false);
 516           }
 517         }
 518       }
 519     });
 520
 521     JMenuItem selCols = new JMenuItem(
 522             MessageManager.getString("label.select_columns_containing"));
 523     selCols.addActionListener(new ActionListener()
 524     {
 525       @Override
 526       public void actionPerformed(ActionEvent arg0)
 527       {
 528         String[] types = getTermsInScope(type);
 529         fr.ap.alignFrame.avc.markColumnsContainingFeatures(false, false,
 530                 false, types);
 531       }
 532     });
 533     JMenuItem clearCols = new JMenuItem(MessageManager
 534             .getString("label.select_columns_not_containing"));
 535     clearCols.addActionListener(new ActionListener()
 536     {
 537       @Override
 538       public void actionPerformed(ActionEvent arg0)
 539       {
 540         String[] types = getTermsInScope(type);
 541         fr.ap.alignFrame.avc.markColumnsContainingFeatures(true, false,
 542                 false, types);
 543       }
 544     });
 545     JMenuItem hideCols = new JMenuItem(
 546             MessageManager.getString("label.hide_columns_containing"));
 547     hideCols.addActionListener(new ActionListener()
 548     {
 549       @Override
 550       public void actionPerformed(ActionEvent arg0)
 551       {
 552         String[] types = getTermsInScope(type);
 553         fr.ap.alignFrame.hideFeatureColumns(true, types);
 554       }
 555     });
 556     JMenuItem hideOtherCols = new JMenuItem(
 557             MessageManager.getString("label.hide_columns_not_containing"));
 558     hideOtherCols.addActionListener(new ActionListener()
 559     {
 560       @Override
 561       public void actionPerformed(ActionEvent arg0)
 562       {
 563         String[] types = getTermsInScope(type);
 564         fr.ap.alignFrame.hideFeatureColumns(false, types);
 565       }
 566     });
 567     men.add(selCols);
 568     men.add(clearCols);
 569     men.add(hideCols);
 570     men.add(hideOtherCols);
 571     men.show(table, x, y);
 572   }
 573
 574   @Override
 575   synchronized public void discoverAllFeatureData()
 576   {
 577     Set<String> allGroups = new HashSet<>();
 578     AlignmentI alignment = af.getViewport().getAlignment();
 579
 580     for (int i = 0; i < alignment.getHeight(); i++)
 581     {
 582       SequenceI seq = alignment.getSequenceAt(i);
 583       for (String group : seq.getFeatures().getFeatureGroups(true))
 584       {
 585         if (group != null && !allGroups.contains(group))
 586         {
 587           allGroups.add(group);
 588           checkGroupState(group);
 589         }
 590       }
 591     }
 592
 593     resetTable(null);
 594
 595     validate();
 596   }
 597
 598   /**
 599    * Synchronise gui group list and check visibility of group
 600    *
 601    * @param group
 602    * @return true if group is visible
 603    */
 604   private boolean checkGroupState(String group)
 605   {
 606     boolean visible = fr.checkGroupVisibility(group, true);
 607
 608     for (int g = 0; g < groupPanel.getComponentCount(); g++)
 609     {
 610       if (((JCheckBox) groupPanel.getComponent(g)).getText().equals(group))
 611       {
 612         ((JCheckBox) groupPanel.getComponent(g)).setSelected(visible);
 613         return visible;
 614       }
 615     }
 616
 617     final String grp = group;
 618     final JCheckBox check = new JCheckBox(group, visible);
 619     check.setFont(new Font("Serif", Font.BOLD, 12));
 620     check.setToolTipText(group);
 621     check.addItemListener(new ItemListener()
 622     {
 623       @Override
 624       public void itemStateChanged(ItemEvent evt)
 625       {
 626         fr.setGroupVisibility(check.getText(), check.isSelected());
 627         resetTable(new String[] { grp });
 628         refreshDisplay();
 629       }
 630     });
 631     groupPanel.add(check);
 632     return visible;
 633   }
 634
 635   synchronized void resetTable(String[] groupChanged)
 636   {
 637     if (resettingTable)
 638     {
 639       return;
 640     }
 641     resettingTable = true;
 642     typeWidth = new Hashtable<>();
 643     // TODO: change avWidth calculation to 'per-sequence' average and use long
 644     // rather than float
 645
 646     Set<String> displayableTypes = new HashSet<>();
 647     Set<String> foundGroups = new HashSet<>();
 648
 649     /*
 650      * determine which feature types may be visible depending on
 651      * which groups are selected, and recompute average width data
 652      */
 653     for (int i = 0; i < af.getViewport().getAlignment().getHeight(); i++)
 654     {
 655
 656       SequenceI seq = af.getViewport().getAlignment().getSequenceAt(i);
 657
 658       /*
 659        * get the sequence's groups for positional features
 660        * and keep track of which groups are visible
 661        */
 662       Set<String> groups = seq.getFeatures().getFeatureGroups(true);
 663       Set<String> visibleGroups = new HashSet<>();
 664       for (String group : groups)
 665       {
 666         if (group == null || checkGroupState(group))
 667         {
 668           visibleGroups.add(group);
 669         }
 670       }
 671       foundGroups.addAll(groups);
 672
 673       /*
 674        * get distinct feature types for visible groups
 675        * record distinct visible types, and their count and total length
 676        */
 677       Set<String> types = seq.getFeatures().getFeatureTypesForGroups(true,
 678               visibleGroups.toArray(new String[visibleGroups.size()]));
 679
 680       for (String type : types)
 681       {
 682         displayableTypes.add(type);
 683         float[] avWidth = typeWidth.get(type);
 684         if (avWidth == null)
 685         {
 686           avWidth = new float[2];
 687           typeWidth.put(type, avWidth);
 688         }
 689         // todo this could include features with a non-visible group
 690         // - do we greatly care?
 691         // todo should we include non-displayable features here, and only
 692         // update when features are added?
 693         avWidth[0] += seq.getFeatures().getFeatureCount(true, type);
 694         avWidth[1] += seq.getFeatures().getTotalFeatureLength(type);
 695       }
 696     }
 697
 698     /*
 699      * enable 'Summary View' if some types are sub-types of others
 700      */
 701     Set<String> parents = SequenceOntologyFactory.getInstance()
 702             .getParentTerms(displayableTypes);
 703     summaryView.setEnabled(parents.size() < displayableTypes.size());
 704
 705     Object[][] data = new Object[displayableTypes.size()][COLUMN_COUNT];
 706     int dataIndex = 0;
 707
 708     if (fr.hasRenderOrder())
 709     {
 710       if (!handlingUpdate)
 711       {
 712         fr.findAllFeatures(groupChanged != null); // prod to update
 713         // colourschemes. but don't
 714         // affect display
 715         // First add the checks in the previous render order,
 716         // in case the window has been closed and reopened
 717       }
 718       List<String> frl = fr.getRenderOrder();
 719       for (int ro = frl.size() - 1; ro > -1; ro--)
 720       {
 721         String type = frl.get(ro);
 722
 723         if (!displayableTypes.contains(type))
 724         {
 725           continue;
 726         }
 727         data[dataIndex][TYPE_COLUMN] = type;
 728         data[dataIndex][COLOUR_COLUMN] = fr.getFeatureStyle(type);
 729         FeatureMatcherSetI featureFilter = fr.getFeatureFilter(type);
 730         data[dataIndex][FILTER_COLUMN] = featureFilter == null
 731                 ? new FeatureMatcherSet()
 732                 : featureFilter;
 733         data[dataIndex][SHOW_COLUMN] = new Boolean(
 734                 af.getViewport().getFeaturesDisplayed().isVisible(type));
 735         dataIndex++;
 736         displayableTypes.remove(type);
 737       }
 738     }
 739
 740     /*
 741      * process any extra features belonging only to
 742      * a group which was just selected
 743      */
 744     while (!displayableTypes.isEmpty())
 745     {
 746       String type = displayableTypes.iterator().next();
 747       data[dataIndex][TYPE_COLUMN] = type;
 748
 749       data[dataIndex][COLOUR_COLUMN] = fr.getFeatureStyle(type);
 750       if (data[dataIndex][COLOUR_COLUMN] == null)
 751       {
 752         // "Colour has been updated in another view!!"
 753         fr.clearRenderOrder();
 754         return;
 755       }
 756       FeatureMatcherSetI featureFilter = fr.getFeatureFilter(type);
 757       data[dataIndex][FILTER_COLUMN] = featureFilter == null
 758               ? new FeatureMatcherSet()
 759               : featureFilter;
 760       data[dataIndex][SHOW_COLUMN] = new Boolean(true);
 761       dataIndex++;
 762       displayableTypes.remove(type);
 763     }
 764
 765     if (originalData == null)
 766     {
 767       originalData = new Object[data.length][COLUMN_COUNT];
 768       for (int i = 0; i < data.length; i++)
 769       {
 770         System.arraycopy(data[i], 0, originalData[i], 0, COLUMN_COUNT);
 771       }
 772     }
 773     else
 774     {
 775       updateOriginalData(data);
 776     }
 777
 778     /*
 779      * recreate the table model
 780      */
 781     FeatureTableModel dataModel = new FeatureTableModel(data);
 782     table.setModel(dataModel);
 783
 784     /*
 785      * we want to be able to filter out rows for sub-types, but not to sort
 786      * rows, so have to add a RowFilter to a disabled TableRowSorter (!)
 787      */
 788     final TableRowSorter<FeatureTableModel> sorter = new TableRowSorter<>(
 789             dataModel);
 790     for (int i = 0; i < table.getColumnCount(); i++)
 791     {
 792       sorter.setSortable(i, false);
 793     }
 794
 795     /*
 796      * filter rows to only top-level Ontology types if requested
 797      */
 798     sorter.setRowFilter(new RowFilter<FeatureTableModel, Integer>()
 799     {
 800       @Override
 801       public boolean include(
 802               Entry<? extends FeatureTableModel, ? extends Integer> entry)
 803       {
 804         if (!summaryView.isSelected())
 805         {
 806           return true;
 807         }
 808         int row = entry.getIdentifier(); // this is model, not view, row number
 809         String featureType = (String) entry.getModel().getData()[row][TYPE_COLUMN];
 810         return parents.contains(featureType);
 811       }
 812     });
 813     table.setRowSorter(sorter);
 814
 815     table.getColumnModel().getColumn(0).setPreferredWidth(200);
 816
 817     groupPanel.setLayout(
 818             new GridLayout(fr.getFeatureGroupsSize() / 4 + 1, 4));
 819     pruneGroups(foundGroups);
 820     groupPanel.validate();
 821
 822     updateFeatureRenderer(data, groupChanged != null);
 823     resettingTable = false;
 824   }
 825
 826   /**
 827    * Updates 'originalData' (used for restore on Cancel) if we detect that changes
 828    * have been made outwith this dialog
 829    * <ul>
 830    * <li>a new feature type added (and made visible)</li>
 831    * <li>a feature colour changed (in the Amend Features dialog)</li>
 832    * </ul>
 833    *
 834    * @param foundData
 835    */
 836   protected void updateOriginalData(Object[][] foundData)
 837   {
 838     // todo LinkedHashMap instead of Object[][] would be nice
 839
 840     Object[][] currentData = ((FeatureTableModel) table.getModel())
 841             .getData();
 842     for (Object[] row : foundData)
 843     {
 844       String type = (String) row[TYPE_COLUMN];
 845       boolean found = false;
 846       for (Object[] current : currentData)
 847       {
 848         if (type.equals(current[TYPE_COLUMN]))
 849         {
 850           found = true;
 851           /*
 852            * currently dependent on object equality here;
 853            * really need an equals method on FeatureColour
 854            */
 855           if (!row[COLOUR_COLUMN].equals(current[COLOUR_COLUMN]))
 856           {
 857             /*
 858              * feature colour has changed externally - update originalData
 859              */
 860             for (Object[] original : originalData)
 861             {
 862               if (type.equals(original[TYPE_COLUMN]))
 863               {
 864                 original[COLOUR_COLUMN] = row[COLOUR_COLUMN];
 865                 break;
 866               }
 867             }
 868           }
 869           break;
 870         }
 871       }
 872       if (!found)
 873       {
 874         /*
 875          * new feature detected - add to original data (on top)
 876          */
 877         Object[][] newData = new Object[originalData.length
 878                 + 1][COLUMN_COUNT];
 879         for (int i = 0; i < originalData.length; i++)
 880         {
 881           System.arraycopy(originalData[i], 0, newData[i + 1], 0,
 882                   COLUMN_COUNT);
 883         }
 884         newData[0] = row;
 885         originalData = newData;
 886       }
 887     }
 888   }
 889
 890   /**
 891    * Remove from the groups panel any checkboxes for groups that are not in the
 892    * foundGroups set. This enables removing a group from the display when the last
 893    * feature in that group is deleted.
 894    *
 895    * @param foundGroups
 896    */
 897   protected void pruneGroups(Set<String> foundGroups)
 898   {
 899     for (int g = 0; g < groupPanel.getComponentCount(); g++)
 900     {
 901       JCheckBox checkbox = (JCheckBox) groupPanel.getComponent(g);
 902       if (!foundGroups.contains(checkbox.getText()))
 903       {
 904         groupPanel.remove(checkbox);
 905       }
 906     }
 907   }
 908
 909   /**
 910    * reorder data based on the featureRenderers global priority list.
 911    *
 912    * @param data
 913    */
 914   private void ensureOrder(Object[][] data)
 915   {
 916     boolean sort = false;
 917     float[] order = new float[data.length];
 918     for (int i = 0; i < order.length; i++)
 919     {
 920       order[i] = fr.getOrder(data[i][0].toString());
 921       if (order[i] < 0)
 922       {
 923         order[i] = fr.setOrder(data[i][0].toString(), i / order.length);
 924       }
 925       if (i > 1)
 926       {
 927         sort = sort || order[i - 1] > order[i];
 928       }
 929     }
 930     if (sort)
 931     {
 932       jalview.util.QuickSort.sort(order, data);
 933     }
 934   }
 935
 936   /**
 937    * Offers a file chooser dialog, and then loads the feature colours and
 938    * filters from file in XML format and unmarshals to Jalview feature settings
 939    */
 940   void load()
 941   {
 942     JalviewFileChooser chooser = new JalviewFileChooser("fc",
 943             SEQUENCE_FEATURE_COLOURS);
 944     chooser.setFileView(new JalviewFileView());
 945     chooser.setDialogTitle(
 946             MessageManager.getString("label.load_feature_colours"));
 947     chooser.setToolTipText(MessageManager.getString("action.load"));
 948
 949     int value = chooser.showOpenDialog(this);
 950
 951     if (value == JalviewFileChooser.APPROVE_OPTION)
 952     {
 953       File file = chooser.getSelectedFile();
 954       load(file);
 955     }
 956   }
 957
 958   /**
 959    * Loads feature colours and filters from XML stored in the given file
 960    *
 961    * @param file
 962    */
 963   void load(File file)
 964   {
 965     try
 966     {
 967       InputStreamReader in = new InputStreamReader(
 968               new FileInputStream(file), "UTF-8");
 969
 970       JAXBContext jc = JAXBContext
 971               .newInstance("jalview.xml.binding.jalview");
 972       javax.xml.bind.Unmarshaller um = jc.createUnmarshaller();
 973       XMLStreamReader streamReader = XMLInputFactory.newInstance()
 974               .createXMLStreamReader(in);
 975       JAXBElement<JalviewUserColours> jbe = um.unmarshal(streamReader,
 976               JalviewUserColours.class);
 977       JalviewUserColours jucs = jbe.getValue();
 978
 979       // JalviewUserColours jucs = JalviewUserColours.unmarshal(in);
 980
 981       /*
 982        * load feature colours
 983        */
 984       for (int i = jucs.getColour().size() - 1; i >= 0; i--)
 985       {
 986         Colour newcol = jucs.getColour().get(i);
 987         FeatureColourI colour = jalview.project.Jalview2XML
 988                 .parseColour(newcol);
 989         fr.setColour(newcol.getName(), colour);
 990         fr.setOrder(newcol.getName(), i / (float) jucs.getColour().size());
 991       }
 992
 993       /*
 994        * load feature filters; loaded filters will replace any that are
 995        * currently defined, other defined filters are left unchanged
 996        */
 997       for (int i = 0; i < jucs.getFilter().size(); i++)
 998       {
 999         Filter filterModel = jucs.getFilter().get(i);
1000         String featureType = filterModel.getFeatureType();
1001         FeatureMatcherSetI filter = jalview.project.Jalview2XML
1002                 .parseFilter(featureType, filterModel.getMatcherSet());
1003         if (!filter.isEmpty())
1004         {
1005           fr.setFeatureFilter(featureType, filter);
1006         }
1007       }
1008
1009       /*
1010        * update feature settings table
1011        */
1012       if (table != null)
1013       {
1014         resetTable(null);
1015         Object[][] data = ((FeatureTableModel) table.getModel())
1016                 .getData();
1017         ensureOrder(data);
1018         updateFeatureRenderer(data, false);
1019         table.repaint();
1020       }
1021     } catch (Exception ex)
1022     {
1023       System.out.println("Error loading User Colour File\n" + ex);
1024     }
1025   }
1026
1027   /**
1028    * Offers a file chooser dialog, and then saves the current feature colours
1029    * and any filters to the selected file in XML format
1030    */
1031   void save()
1032   {
1033     JalviewFileChooser chooser = new JalviewFileChooser("fc",
1034             SEQUENCE_FEATURE_COLOURS);
1035     chooser.setFileView(new JalviewFileView());
1036     chooser.setDialogTitle(
1037             MessageManager.getString("label.save_feature_colours"));
1038     chooser.setToolTipText(MessageManager.getString("action.save"));
1039
1040     int value = chooser.showSaveDialog(this);
1041
1042     if (value == JalviewFileChooser.APPROVE_OPTION)
1043     {
1044       save(chooser.getSelectedFile());
1045     }
1046   }
1047
1048   /**
1049    * Saves feature colours and filters to the given file
1050    *
1051    * @param file
1052    */
1053   void save(File file)
1054   {
1055     JalviewUserColours ucs = new JalviewUserColours();
1056     ucs.setSchemeName("Sequence Features");
1057     try
1058     {
1059       PrintWriter out = new PrintWriter(new OutputStreamWriter(
1060               new FileOutputStream(file), "UTF-8"));
1061
1062       /*
1063        * sort feature types by colour order, from 0 (highest)
1064        * to 1 (lowest)
1065        */
1066       Set<String> fr_colours = fr.getAllFeatureColours();
1067       String[] sortedTypes = fr_colours
1068               .toArray(new String[fr_colours.size()]);
1069       Arrays.sort(sortedTypes, new Comparator<String>()
1070       {
1071         @Override
1072         public int compare(String type1, String type2)
1073         {
1074           return Float.compare(fr.getOrder(type1), fr.getOrder(type2));
1075         }
1076       });
1077
1078       /*
1079        * save feature colours
1080        */
1081       for (String featureType : sortedTypes)
1082       {
1083         FeatureColourI fcol = fr.getFeatureStyle(featureType);
1084         Colour col = jalview.project.Jalview2XML.marshalColour(featureType,
1085                 fcol);
1086         ucs.getColour().add(col);
1087       }
1088
1089       /*
1090        * save any feature filters
1091        */
1092       for (String featureType : sortedTypes)
1093       {
1094         FeatureMatcherSetI filter = fr.getFeatureFilter(featureType);
1095         if (filter != null && !filter.isEmpty())
1096         {
1097           Iterator<FeatureMatcherI> iterator = filter.getMatchers().iterator();
1098           FeatureMatcherI firstMatcher = iterator.next();
1099           jalview.xml.binding.jalview.FeatureMatcherSet ms = jalview.project.Jalview2XML
1100                   .marshalFilter(firstMatcher, iterator,
1101                   filter.isAnded());
1102           Filter filterModel = new Filter();
1103           filterModel.setFeatureType(featureType);
1104           filterModel.setMatcherSet(ms);
1105           ucs.getFilter().add(filterModel);
1106         }
1107       }
1108       JAXBContext jaxbContext = JAXBContext
1109               .newInstance(JalviewUserColours.class);
1110       Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
1111       jaxbMarshaller.marshal(
1112               new ObjectFactory().createJalviewUserColours(ucs), out);
1113
1114       // jaxbMarshaller.marshal(object, pout);
1115       // marshaller.marshal(object);
1116       out.flush();
1117
1118       // ucs.marshal(out);
1119       out.close();
1120     } catch (Exception ex)
1121     {
1122       ex.printStackTrace();
1123     }
1124   }
1125
1126   public void invertSelection()
1127   {
1128     Object[][] data = ((FeatureTableModel) table.getModel()).getData();
1129     for (int i = 0; i < data.length; i++)
1130     {
1131       data[i][SHOW_COLUMN] = !(Boolean) data[i][SHOW_COLUMN];
1132     }
1133     updateFeatureRenderer(data, true);
1134     table.repaint();
1135   }
1136
1137   public void orderByAvWidth()
1138   {
1139     if (table == null || table.getModel() == null)
1140     {
1141       return;
1142     }
1143     Object[][] data = ((FeatureTableModel) table.getModel()).getData();
1144     float[] width = new float[data.length];
1145     float[] awidth;
1146     float max = 0;
1147
1148     for (int i = 0; i < data.length; i++)
1149     {
1150       awidth = typeWidth.get(data[i][TYPE_COLUMN]);
1151       if (awidth[0] > 0)
1152       {
1153         width[i] = awidth[1] / awidth[0];// *awidth[0]*awidth[2]; - better
1154         // weight - but have to make per
1155         // sequence, too (awidth[2])
1156         // if (width[i]==1) // hack to distinguish single width sequences.
1157       }
1158       else
1159       {
1160         width[i] = 0;
1161       }
1162       if (max < width[i])
1163       {
1164         max = width[i];
1165       }
1166     }
1167     boolean sort = false;
1168     for (int i = 0; i < width.length; i++)
1169     {
1170       // awidth = (float[]) typeWidth.get(data[i][0]);
1171       if (width[i] == 0)
1172       {
1173         width[i] = fr.getOrder(data[i][TYPE_COLUMN].toString());
1174         if (width[i] < 0)
1175         {
1176           width[i] = fr.setOrder(data[i][TYPE_COLUMN].toString(),
1177                   i / data.length);
1178         }
1179       }
1180       else
1181       {
1182         width[i] /= max; // normalize
1183         fr.setOrder(data[i][TYPE_COLUMN].toString(), width[i]); // store for later
1184       }
1185       if (i > 0)
1186       {
1187         sort = sort || width[i - 1] > width[i];
1188       }
1189     }
1190     if (sort)
1191     {
1192       jalview.util.QuickSort.sort(width, data);
1193       // update global priority order
1194     }
1195
1196     updateFeatureRenderer(data, false);
1197     table.repaint();
1198   }
1199
1200   public void close()
1201   {
1202     try
1203     {
1204       frame.setClosed(true);
1205     } catch (Exception exe)
1206     {
1207     }
1208
1209   }
1210
1211   public void updateFeatureRenderer(Object[][] data)
1212   {
1213     updateFeatureRenderer(data, true);
1214   }
1215
1216   /**
1217    * Update the priority order of features; only repaint if this changed the order
1218    * of visible features
1219    *
1220    * @param data
1221    * @param visibleNew
1222    */
1223   private void updateFeatureRenderer(Object[][] data, boolean visibleNew)
1224   {
1225     FeatureSettingsBean[] rowData = getTableAsBeans(data);
1226
1227     if (fr.setFeaturePriority(rowData, visibleNew))
1228     {
1229       refreshDisplay();
1230     }
1231   }
1232
1233   /**
1234    * Converts table data into an array of data beans
1235    */
1236   private FeatureSettingsBean[] getTableAsBeans(Object[][] data)
1237   {
1238     FeatureSettingsBean[] rowData = new FeatureSettingsBean[data.length];
1239     for (int i = 0; i < data.length; i++)
1240     {
1241       String type = (String) data[i][TYPE_COLUMN];
1242       FeatureColourI colour = (FeatureColourI) data[i][COLOUR_COLUMN];
1243       FeatureMatcherSetI theFilter = (FeatureMatcherSetI) data[i][FILTER_COLUMN];
1244       Boolean isShown = (Boolean) data[i][SHOW_COLUMN];
1245       rowData[i] = new FeatureSettingsBean(type, colour, theFilter,
1246               isShown);
1247     }
1248     return rowData;
1249   }
1250
1251   private void jbInit() throws Exception
1252   {
1253     this.setLayout(new BorderLayout());
1254
1255     JPanel settingsPane = new JPanel();
1256     settingsPane.setLayout(new BorderLayout());
1257
1258     JPanel bigPanel = new JPanel();
1259     bigPanel.setLayout(new BorderLayout());
1260
1261     groupPanel = new JPanel();
1262     bigPanel.add(groupPanel, BorderLayout.NORTH);
1263
1264     JButton invert = new JButton(
1265             MessageManager.getString("label.invert_selection"));
1266     invert.setFont(JvSwingUtils.getLabelFont());
1267     invert.addActionListener(new ActionListener()
1268     {
1269       @Override
1270       public void actionPerformed(ActionEvent e)
1271       {
1272         invertSelection();
1273       }
1274     });
1275
1276     JButton optimizeOrder = new JButton(
1277             MessageManager.getString("label.optimise_order"));
1278     optimizeOrder.setFont(JvSwingUtils.getLabelFont());
1279     optimizeOrder.addActionListener(new ActionListener()
1280     {
1281       @Override
1282       public void actionPerformed(ActionEvent e)
1283       {
1284         orderByAvWidth();
1285       }
1286     });
1287
1288     JButton sortByScore = new JButton(
1289             MessageManager.getString("label.seq_sort_by_score"));
1290     sortByScore.setFont(JvSwingUtils.getLabelFont());
1291     sortByScore.addActionListener(new ActionListener()
1292     {
1293       @Override
1294       public void actionPerformed(ActionEvent e)
1295       {
1296         af.avc.sortAlignmentByFeatureScore(null);
1297       }
1298     });
1299     JButton sortByDens = new JButton(
1300             MessageManager.getString("label.sequence_sort_by_density"));
1301     sortByDens.setFont(JvSwingUtils.getLabelFont());
1302     sortByDens.addActionListener(new ActionListener()
1303     {
1304       @Override
1305       public void actionPerformed(ActionEvent e)
1306       {
1307         af.avc.sortAlignmentByFeatureDensity(null);
1308       }
1309     });
1310
1311     JButton help = new JButton(MessageManager.getString("action.help"));
1312     help.setFont(JvSwingUtils.getLabelFont());
1313     help.addActionListener(new ActionListener()
1314     {
1315       @Override
1316       public void actionPerformed(ActionEvent e)
1317       {
1318         try
1319         {
1320           Help.showHelpWindow(HelpId.SequenceFeatureSettings);
1321         } catch (HelpSetException e1)
1322         {
1323           e1.printStackTrace();
1324         }
1325       }
1326     });
1327     help.setFont(JvSwingUtils.getLabelFont());
1328     help.setText(MessageManager.getString("action.help"));
1329     help.addActionListener(new ActionListener()
1330     {
1331       @Override
1332       public void actionPerformed(ActionEvent e)
1333       {
1334         try
1335         {
1336           Help.showHelpWindow(HelpId.SequenceFeatureSettings);
1337         } catch (HelpSetException e1)
1338         {
1339           e1.printStackTrace();
1340         }
1341       }
1342     });
1343
1344     JButton cancel = new JButton(MessageManager.getString("action.cancel"));
1345     cancel.setFont(JvSwingUtils.getLabelFont());
1346     cancel.addActionListener(new ActionListener()
1347     {
1348       @Override
1349       public void actionPerformed(ActionEvent e)
1350       {
1351         fr.setTransparency(originalTransparency);
1352         fr.setFeatureFilters(originalFilters);
1353         updateFeatureRenderer(originalData);
1354         af.getViewport().setViewStyle(originalViewStyle);
1355         close();
1356       }
1357     });
1358
1359     JButton ok = new JButton(MessageManager.getString("action.ok"));
1360     ok.setFont(JvSwingUtils.getLabelFont());
1361     ok.addActionListener(new ActionListener()
1362     {
1363       @Override
1364       public void actionPerformed(ActionEvent e)
1365       {
1366         close();
1367       }
1368     });
1369
1370     JButton loadColours = new JButton(
1371             MessageManager.getString("label.load_colours"));
1372     loadColours.setFont(JvSwingUtils.getLabelFont());
1373     loadColours.setToolTipText(
1374             MessageManager.getString("label.load_colours_tooltip"));
1375     loadColours.addActionListener(new ActionListener()
1376     {
1377       @Override
1378       public void actionPerformed(ActionEvent e)
1379       {
1380         load();
1381       }
1382     });
1383
1384     JButton saveColours = new JButton(
1385             MessageManager.getString("label.save_colours"));
1386     saveColours.setFont(JvSwingUtils.getLabelFont());
1387     saveColours.setToolTipText(
1388             MessageManager.getString("label.save_colours_tooltip"));
1389     saveColours.addActionListener(new ActionListener()
1390     {
1391       @Override
1392       public void actionPerformed(ActionEvent e)
1393       {
1394         save();
1395       }
1396     });
1397     transparency.addChangeListener(new ChangeListener()
1398     {
1399       @Override
1400       public void stateChanged(ChangeEvent evt)
1401       {
1402         if (!inConstruction)
1403         {
1404           fr.setTransparency((100 - transparency.getValue()) / 100f);
1405           refreshDisplay();
1406         }
1407       }
1408     });
1409
1410     summaryView = new JCheckBox(
1411             MessageManager.getString("label.summary_view"));
1412     summaryView
1413             .setToolTipText(
1414                     MessageManager.getString("label.summary_view_tip"));
1415     summaryView.addActionListener(new ActionListener()
1416     {
1417       @Override
1418       public void actionPerformed(ActionEvent e)
1419       {
1420         resetTable(null);
1421       }
1422     });
1423
1424     transparency.setMaximum(70);
1425     transparency.setToolTipText(
1426             MessageManager.getString("label.transparency_tip"));
1427
1428     boolean nucleotide = af.getViewport().getAlignment().isNucleotide();
1429     showComplement = new JCheckBox(
1430             "Show " + (nucleotide ? "protein" : "CDS") + " features");
1431     showComplement.setSelected(af.getViewport().isShowComplementFeatures());
1432     showComplement.addActionListener(new ActionListener()
1433     {
1434       @Override
1435       public void actionPerformed(ActionEvent e)
1436       {
1437         af.getViewport()
1438                 .setShowComplementFeatures(showComplement.isSelected());
1439         refreshDisplay();
1440       }
1441     });
1442
1443     showComplementOnTop = new JCheckBox("on top");
1444     showComplementOnTop
1445             .setSelected(af.getViewport().isShowComplementFeaturesOnTop());
1446     showComplementOnTop.addActionListener(new ActionListener()
1447     {
1448       @Override
1449       public void actionPerformed(ActionEvent e)
1450       {
1451         af.getViewport().setShowComplementFeaturesOnTop(
1452                 showComplementOnTop.isSelected());
1453         refreshDisplay();
1454       }
1455     });
1456
1457     JPanel lowerPanel = new JPanel(new GridLayout(1, 2));
1458     bigPanel.add(lowerPanel, BorderLayout.SOUTH);
1459
1460     JPanel transbuttons = new JPanel(new GridLayout(5, 1));
1461     transbuttons.add(optimizeOrder);
1462     transbuttons.add(invert);
1463     transbuttons.add(sortByScore);
1464     transbuttons.add(sortByDens);
1465     transbuttons.add(help);
1466
1467     boolean hasComplement = af.getViewport().getCodingComplement() != null;
1468     JPanel transPanelLeft = new JPanel(
1469             new GridLayout(hasComplement ? 4 : 3, 1));
1470     transPanelLeft.add(summaryView);
1471     transPanelLeft.add(new JLabel(" Colour transparency" + ":"));
1472     transPanelLeft.add(transparency);
1473     if (hasComplement)
1474     {
1475       JPanel cp = new JPanel(new FlowLayout(FlowLayout.LEFT));
1476       cp.add(showComplement);
1477       cp.add(showComplementOnTop);
1478       transPanelLeft.add(cp);
1479     }
1480     lowerPanel.add(transPanelLeft);
1481     lowerPanel.add(transbuttons);
1482
1483     JPanel buttonPanel = new JPanel();
1484     buttonPanel.add(ok);
1485     buttonPanel.add(cancel);
1486     buttonPanel.add(loadColours);
1487     buttonPanel.add(saveColours);
1488     bigPanel.add(scrollPane, BorderLayout.CENTER);
1489     settingsPane.add(bigPanel, BorderLayout.CENTER);
1490     settingsPane.add(buttonPanel, BorderLayout.SOUTH);
1491     this.add(settingsPane);
1492   }
1493
1494   /**
1495    * Repaints alignment, structure and overview (if shown). If there is a
1496    * complementary view which is showing this view's features, then also
1497    * repaints that.
1498    */
1499   void refreshDisplay()
1500   {
1501     af.alignPanel.paintAlignment(true, true);
1502     AlignViewportI complement = af.getViewport().getCodingComplement();
1503     if (complement != null && complement.isShowComplementFeatures())
1504     {
1505       AlignFrame af2 = Desktop.getAlignFrameFor(complement);
1506       af2.alignPanel.paintAlignment(true, true);
1507     }
1508   }
1509
1510   /**
1511    * Reorders features by 'dragging' selectedRow to 'newRow'
1512    *
1513    * @param newRow
1514    */
1515   protected void dragRow(int newRow)
1516   {
1517     if (summaryView.isSelected())
1518     {
1519       // no drag while in summary view
1520       return;
1521     }
1522
1523     if (newRow != selectedRow && selectedRow != -1 && newRow != -1)
1524     {
1525       /*
1526        * reposition 'selectedRow' to 'newRow' (the dragged to location)
1527        * this could be more than one row away for a very fast drag action
1528        * so just swap it with adjacent rows until we get it there
1529        */
1530       Object[][] data = ((FeatureTableModel) table.getModel())
1531               .getData();
1532       int direction = newRow < selectedRow ? -1 : 1;
1533       for (int i = selectedRow; i != newRow; i += direction)
1534       {
1535         Object[] temp = data[i];
1536         data[i] = data[i + direction];
1537         data[i + direction] = temp;
1538       }
1539       updateFeatureRenderer(data);
1540       table.repaint();
1541       selectedRow = newRow;
1542     }
1543   }
1544
1545   protected void refreshTable()
1546   {
1547     Object[][] data = ((FeatureTableModel) table.getModel()).getData();
1548     for (Object[] row : data)
1549     {
1550       String type = (String) row[TYPE_COLUMN];
1551       FeatureColourI colour = fr.getFeatureColours().get(type);
1552       FeatureMatcherSetI filter = fr.getFeatureFilter(type);
1553       if (filter == null)
1554       {
1555         filter = new FeatureMatcherSet();
1556       }
1557       row[COLOUR_COLUMN] = colour;
1558       row[FILTER_COLUMN] = filter;
1559     }
1560     repaint();
1561   }
1562
1563   // ///////////////////////////////////////////////////////////////////////
1564   // http://java.sun.com/docs/books/tutorial/uiswing/components/table.html
1565   // ///////////////////////////////////////////////////////////////////////
1566   class FeatureTableModel extends AbstractTableModel
1567   {
1568     private String[] columnNames = {
1569         MessageManager.getString("label.feature_type"),
1570         MessageManager.getString("action.colour"),
1571         MessageManager.getString("label.configuration"),
1572         MessageManager.getString("label.show") };
1573
1574     private Object[][] data;
1575
1576     FeatureTableModel(Object[][] data)
1577     {
1578       this.data = data;
1579     }
1580
1581     public Object[][] getData()
1582     {
1583       return data;
1584     }
1585
1586     public void setData(Object[][] data)
1587     {
1588       this.data = data;
1589     }
1590
1591     @Override
1592     public int getColumnCount()
1593     {
1594       return columnNames.length;
1595     }
1596
1597     public Object[] getRow(int row)
1598     {
1599       return data[row];
1600     }
1601
1602     @Override
1603     public int getRowCount()
1604     {
1605       return data.length;
1606     }
1607
1608     @Override
1609     public String getColumnName(int col)
1610     {
1611       return columnNames[col];
1612     }
1613
1614     @Override
1615     public Object getValueAt(int row, int col)
1616     {
1617       return data[row][col];
1618     }
1619
1620     /**
1621      * Answers the class of column c of the table
1622      */
1623     @Override
1624     public Class<?> getColumnClass(int c)
1625     {
1626       switch (c)
1627       {
1628       case TYPE_COLUMN:
1629         return String.class;
1630       case COLOUR_COLUMN:
1631         return FeatureColour.class;
1632       case FILTER_COLUMN:
1633         return FeatureMatcherSet.class;
1634       default:
1635         return Boolean.class;
1636       }
1637     }
1638
1639     /**
1640      * Answers true for all columns except Feature Type
1641      */
1642     @Override
1643     public boolean isCellEditable(int row, int col)
1644     {
1645       return col != TYPE_COLUMN;
1646     }
1647
1648     /**
1649      * Sets the value in the model for a given row and column. If Visibility
1650      * (Show/Hide) is being set, and the table is in Summary View, then it is
1651      * set also on any sub-types of the row's feature type.
1652      */
1653     @Override
1654     public void setValueAt(Object value, int row, int col)
1655     {
1656       data[row][col] = value;
1657       fireTableCellUpdated(row, col);
1658       if (summaryView.isSelected() && col == SHOW_COLUMN)
1659       {
1660         setSubtypesVisibility(row, (Boolean) value);
1661       }
1662       updateFeatureRenderer(data);
1663     }
1664
1665     /**
1666      * Sets the visibility of any feature types which are sub-types of the type
1667      * in the given row of the table
1668      *
1669      * @param row
1670      * @param value
1671      */
1672     protected void setSubtypesVisibility(int row, Boolean value)
1673     {
1674       String type = (String) data[row][TYPE_COLUMN];
1675       OntologyI so = SequenceOntologyFactory.getInstance();
1676
1677       for (int r = 0; r < data.length; r++)
1678       {
1679         if (r != row)
1680         {
1681           String type2 = (String) data[r][TYPE_COLUMN];
1682           if (so.isA(type2, type))
1683           {
1684             data[r][SHOW_COLUMN] = value;
1685             fireTableCellUpdated(r, SHOW_COLUMN);
1686           }
1687         }
1688       }
1689     }
1690   }
1691
1692   class ColorRenderer extends JLabel implements TableCellRenderer
1693   {
1694     javax.swing.border.Border unselectedBorder = null;
1695
1696     javax.swing.border.Border selectedBorder = null;
1697
1698     final String baseTT = "Click to edit, right/apple click for menu.";
1699
1700     public ColorRenderer()
1701     {
1702       setOpaque(true); // MUST do this for background to show up.
1703       setHorizontalTextPosition(SwingConstants.CENTER);
1704       setVerticalTextPosition(SwingConstants.CENTER);
1705     }
1706
1707     @Override
1708     public Component getTableCellRendererComponent(JTable tbl, Object color,
1709             boolean isSelected, boolean hasFocus, int row, int column)
1710     {
1711       FeatureColourI cellColour = (FeatureColourI) color;
1712       setOpaque(true);
1713       setToolTipText(baseTT);
1714       setBackground(tbl.getBackground());
1715       if (!cellColour.isSimpleColour())
1716       {
1717         Rectangle cr = tbl.getCellRect(row, column, false);
1718         FeatureSettings.renderGraduatedColor(this, cellColour,
1719                 (int) cr.getWidth(), (int) cr.getHeight());
1720       }
1721       else
1722       {
1723         this.setText("");
1724         this.setIcon(null);
1725         setBackground(cellColour.getColour());
1726       }
1727       if (isSelected)
1728       {
1729         if (selectedBorder == null)
1730         {
1731           selectedBorder = BorderFactory.createMatteBorder(2, 5, 2, 5,
1732                   tbl.getSelectionBackground());
1733         }
1734         setBorder(selectedBorder);
1735       }
1736       else
1737       {
1738         if (unselectedBorder == null)
1739         {
1740           unselectedBorder = BorderFactory.createMatteBorder(2, 5, 2, 5,
1741                   tbl.getBackground());
1742         }
1743         setBorder(unselectedBorder);
1744       }
1745
1746       return this;
1747     }
1748   }
1749
1750   class FilterRenderer extends JLabel implements TableCellRenderer
1751   {
1752     javax.swing.border.Border unselectedBorder = null;
1753
1754     javax.swing.border.Border selectedBorder = null;
1755
1756     public FilterRenderer()
1757     {
1758       setOpaque(true); // MUST do this for background to show up.
1759       setHorizontalTextPosition(SwingConstants.CENTER);
1760       setVerticalTextPosition(SwingConstants.CENTER);
1761     }
1762
1763     @Override
1764     public Component getTableCellRendererComponent(JTable tbl,
1765             Object filter, boolean isSelected, boolean hasFocus, int row,
1766             int column)
1767     {
1768       FeatureMatcherSetI theFilter = (FeatureMatcherSetI) filter;
1769       setOpaque(true);
1770       String asText = theFilter.toString();
1771       setBackground(tbl.getBackground());
1772       this.setText(asText);
1773       this.setIcon(null);
1774
1775       if (isSelected)
1776       {
1777         if (selectedBorder == null)
1778         {
1779           selectedBorder = BorderFactory.createMatteBorder(2, 5, 2, 5,
1780                   tbl.getSelectionBackground());
1781         }
1782         setBorder(selectedBorder);
1783       }
1784       else
1785       {
1786         if (unselectedBorder == null)
1787         {
1788           unselectedBorder = BorderFactory.createMatteBorder(2, 5, 2, 5,
1789                   tbl.getBackground());
1790         }
1791         setBorder(unselectedBorder);
1792       }
1793
1794       return this;
1795     }
1796   }
1797
1798   /**
1799    * update comp using rendering settings from gcol
1800    *
1801    * @param comp
1802    * @param gcol
1803    */
1804   public static void renderGraduatedColor(JLabel comp, FeatureColourI gcol)
1805   {
1806     int w = comp.getWidth(), h = comp.getHeight();
1807     if (w < 20)
1808     {
1809       w = (int) comp.getPreferredSize().getWidth();
1810       h = (int) comp.getPreferredSize().getHeight();
1811       if (w < 20)
1812       {
1813         w = 80;
1814         h = 12;
1815       }
1816     }
1817     renderGraduatedColor(comp, gcol, w, h);
1818   }
1819
1820   public static void renderGraduatedColor(JLabel comp, FeatureColourI gcol,
1821           int w, int h)
1822   {
1823     boolean thr = false;
1824     StringBuilder tt = new StringBuilder();
1825     StringBuilder tx = new StringBuilder();
1826
1827     if (gcol.isColourByAttribute())
1828     {
1829       tx.append(String.join(":", gcol.getAttributeName()));
1830     }
1831     else if (!gcol.isColourByLabel())
1832     {
1833       tx.append(MessageManager.getString("label.score"));
1834     }
1835     tx.append(" ");
1836     if (gcol.isAboveThreshold())
1837     {
1838       thr = true;
1839       tx.append(">");
1840       tt.append("Thresholded (Above ").append(gcol.getThreshold())
1841               .append(") ");
1842     }
1843     if (gcol.isBelowThreshold())
1844     {
1845       thr = true;
1846       tx.append("<");
1847       tt.append("Thresholded (Below ").append(gcol.getThreshold())
1848               .append(") ");
1849     }
1850     if (gcol.isColourByLabel())
1851     {
1852       tt.append("Coloured by label text. ").append(tt);
1853       if (thr)
1854       {
1855         tx.append(" ");
1856       }
1857       if (!gcol.isColourByAttribute())
1858       {
1859         tx.append("Label");
1860       }
1861       comp.setIcon(null);
1862     }
1863     else
1864     {
1865       Color newColor = gcol.getMaxColour();
1866       comp.setBackground(newColor);
1867       // System.err.println("Width is " + w / 2);
1868       Icon ficon = new FeatureIcon(gcol, comp.getBackground(), w, h, thr);
1869       comp.setIcon(ficon);
1870       // tt+="RGB value: Max (" + newColor.getRed() + ", "
1871       // + newColor.getGreen() + ", " + newColor.getBlue()
1872       // + ")\nMin (" + minCol.getRed() + ", " + minCol.getGreen()
1873       // + ", " + minCol.getBlue() + ")");
1874     }
1875     comp.setHorizontalAlignment(SwingConstants.CENTER);
1876     comp.setText(tx.toString());
1877     if (tt.length() > 0)
1878     {
1879       if (comp.getToolTipText() == null)
1880       {
1881         comp.setToolTipText(tt.toString());
1882       }
1883       else
1884       {
1885         comp.setToolTipText(
1886                 tt.append(" ").append(comp.getToolTipText()).toString());
1887       }
1888     }
1889   }
1890
1891   class ColorEditor extends AbstractCellEditor
1892           implements TableCellEditor, ActionListener
1893   {
1894     FeatureSettings me;
1895
1896     FeatureColourI currentColor;
1897
1898     FeatureTypeSettings chooser;
1899
1900     String type;
1901
1902     JButton colourButton;
1903
1904     JColorChooser colorChooser;
1905
1906     JDialog dialog;
1907
1908     protected static final String EDIT = "edit";
1909
1910     int rowSelected = 0;
1911
1912     public ColorEditor(FeatureSettings me)
1913     {
1914       this.me = me;
1915       // Set up the editor (from the table's point of view),
1916       // which is a button.
1917       // This button brings up the color chooser dialog,
1918       // which is the editor from the user's point of view.
1919       colourButton = new JButton();
1920       colourButton.setActionCommand(EDIT);
1921       colourButton.addActionListener(this);
1922       colourButton.setBorderPainted(false);
1923       // Set up the dialog that the button brings up.
1924       colorChooser = new JColorChooser();
1925       dialog = JColorChooser.createDialog(colourButton,
1926               MessageManager.getString("label.select_colour"), true, // modal
1927               colorChooser, this, // OK button handler
1928               null); // no CANCEL button handler
1929     }
1930
1931     /**
1932      * Handles events from the editor button and from the dialog's OK button.
1933      */
1934     @Override
1935     public void actionPerformed(ActionEvent e)
1936     {
1937       // todo test e.getSource() instead here
1938       if (EDIT.equals(e.getActionCommand()))
1939       {
1940         // The user has clicked the cell, so
1941         // bring up the dialog.
1942         if (currentColor.isSimpleColour())
1943         {
1944           // bring up simple color chooser
1945           colourButton.setBackground(currentColor.getColour());
1946           colorChooser.setColor(currentColor.getColour());
1947           dialog.setVisible(true);
1948         }
1949         else
1950         {
1951           // bring up graduated chooser.
1952           chooser = new FeatureTypeSettings(me.fr, type);
1953           chooser.setRequestFocusEnabled(true);
1954           chooser.requestFocus();
1955           chooser.addActionListener(this);
1956           // Make the renderer reappear.
1957           fireEditingStopped();
1958         }
1959       }
1960       else
1961       {
1962         if (currentColor.isSimpleColour())
1963         {
1964           /*
1965            * read off colour picked in colour chooser after OK pressed
1966            */
1967           currentColor = new FeatureColour(colorChooser.getColor());
1968           me.table.setValueAt(currentColor, rowSelected, COLOUR_COLUMN);
1969         }
1970         else
1971         {
1972           /*
1973            * after OK in variable colour dialog, any changes to colour
1974            * (or filters!) are already set in FeatureRenderer, so just
1975            * update table data without triggering updateFeatureRenderer
1976            */
1977           refreshTable();
1978         }
1979         fireEditingStopped();
1980         me.table.validate();
1981       }
1982     }
1983
1984     // Implement the one CellEditor method that AbstractCellEditor doesn't.
1985     @Override
1986     public Object getCellEditorValue()
1987     {
1988       return currentColor;
1989     }
1990
1991     // Implement the one method defined by TableCellEditor.
1992     @Override
1993     public Component getTableCellEditorComponent(JTable theTable, Object value,
1994             boolean isSelected, int row, int column)
1995     {
1996       currentColor = (FeatureColourI) value;
1997       this.rowSelected = row;
1998       type = me.table.getValueAt(row, TYPE_COLUMN).toString();
1999       colourButton.setOpaque(true);
2000       colourButton.setBackground(me.getBackground());
2001       if (!currentColor.isSimpleColour())
2002       {
2003         JLabel btn = new JLabel();
2004         btn.setSize(colourButton.getSize());
2005         FeatureSettings.renderGraduatedColor(btn, currentColor);
2006         colourButton.setBackground(btn.getBackground());
2007         colourButton.setIcon(btn.getIcon());
2008         colourButton.setText(btn.getText());
2009       }
2010       else
2011       {
2012         colourButton.setText("");
2013         colourButton.setIcon(null);
2014         colourButton.setBackground(currentColor.getColour());
2015       }
2016       return colourButton;
2017     }
2018   }
2019
2020   /**
2021    * The cell editor for the Filter column. It displays the text of any filters
2022    * for the feature type in that row (in full as a tooltip, possible abbreviated
2023    * as display text). On click in the cell, opens the Feature Display Settings
2024    * dialog at the Filters tab.
2025    */
2026   class FilterEditor extends AbstractCellEditor
2027           implements TableCellEditor, ActionListener
2028   {
2029     FeatureSettings me;
2030
2031     FeatureMatcherSetI currentFilter;
2032
2033     Point lastLocation;
2034
2035     String type;
2036
2037     JButton filterButton;
2038
2039     protected static final String EDIT = "edit";
2040
2041     int rowSelected = 0;
2042
2043     public FilterEditor(FeatureSettings me)
2044     {
2045       this.me = me;
2046       filterButton = new JButton();
2047       filterButton.setActionCommand(EDIT);
2048       filterButton.addActionListener(this);
2049       filterButton.setBorderPainted(false);
2050     }
2051
2052     /**
2053      * Handles events from the editor button
2054      */
2055     @Override
2056     public void actionPerformed(ActionEvent e)
2057     {
2058       if (filterButton == e.getSource())
2059       {
2060         FeatureTypeSettings chooser = new FeatureTypeSettings(me.fr, type);
2061         chooser.addActionListener(this);
2062         chooser.setRequestFocusEnabled(true);
2063         chooser.requestFocus();
2064         if (lastLocation != null)
2065         {
2066           // todo open at its last position on screen
2067           chooser.setBounds(lastLocation.x, lastLocation.y,
2068                   chooser.getWidth(), chooser.getHeight());
2069           chooser.validate();
2070         }
2071         fireEditingStopped();
2072       }
2073       else if (e.getSource() instanceof Component)
2074       {
2075         /*
2076          * after OK in variable colour dialog, any changes to filter
2077          * (or colours!) are already set in FeatureRenderer, so just
2078          * update table data without triggering updateFeatureRenderer
2079          */
2080         refreshTable();
2081         fireEditingStopped();
2082         me.table.validate();
2083       }
2084     }
2085
2086     @Override
2087     public Object getCellEditorValue()
2088     {
2089       return currentFilter;
2090     }
2091
2092     @Override
2093     public Component getTableCellEditorComponent(JTable theTable, Object value,
2094             boolean isSelected, int row, int column)
2095     {
2096       currentFilter = (FeatureMatcherSetI) value;
2097       this.rowSelected = row;
2098       type = me.table.getValueAt(row, TYPE_COLUMN).toString();
2099       filterButton.setOpaque(true);
2100       filterButton.setBackground(me.getBackground());
2101       filterButton.setText(currentFilter.toString());
2102       filterButton.setToolTipText(currentFilter.toString());
2103       filterButton.setIcon(null);
2104       return filterButton;
2105     }
2106   }
2107 }
2108
2109 class FeatureIcon implements Icon
2110 {
2111   private static final Font VERDANA_9 = new Font("Verdana", Font.PLAIN, 9);
2112
2113   FeatureColourI gcol;
2114
2115   Color backg;
2116
2117   boolean midspace = false;
2118
2119   int width = 50, height = 20;
2120
2121   int s1, e1; // start and end of midpoint band for thresholded symbol
2122
2123   Color mpcolour = Color.white;
2124
2125   FeatureIcon(FeatureColourI gfc, Color bg, int w, int h, boolean mspace)
2126   {
2127     gcol = gfc;
2128     backg = bg;
2129     width = w;
2130     height = h;
2131     midspace = mspace;
2132     if (midspace)
2133     {
2134       s1 = width / 3;
2135       e1 = s1 * 2;
2136     }
2137     else
2138     {
2139       s1 = width / 2;
2140       e1 = s1;
2141     }
2142   }
2143
2144   @Override
2145   public int getIconWidth()
2146   {
2147     return width;
2148   }
2149
2150   @Override
2151   public int getIconHeight()
2152   {
2153     return height;
2154   }
2155
2156   @Override
2157   public void paintIcon(Component c, Graphics g, int x, int y)
2158   {
2159
2160     if (gcol.isColourByLabel())
2161     {
2162       g.setColor(backg);
2163       g.fillRect(0, 0, width, height);
2164       // need an icon here.
2165       g.setColor(gcol.getMaxColour());
2166
2167       g.setFont(VERDANA_9);
2168
2169       // g.setFont(g.getFont().deriveFont(
2170       // AffineTransform.getScaleInstance(
2171       // width/g.getFontMetrics().stringWidth("Label"),
2172       // height/g.getFontMetrics().getHeight())));
2173
2174       g.drawString(MessageManager.getString("label.label"), 0, 0);
2175
2176     }
2177     else
2178     {
2179       Color minCol = gcol.getMinColour();
2180       g.setColor(minCol);
2181       g.fillRect(0, 0, s1, height);
2182       if (midspace)
2183       {
2184         g.setColor(Color.white);
2185         g.fillRect(s1, 0, e1 - s1, height);
2186       }
2187       g.setColor(gcol.getMaxColour());
2188       g.fillRect(0, e1, width - e1, height);
2189     }
2190   }
2191 }