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.FeatureColourI;
  24 import jalview.api.FeatureSettingsControllerI;
  25 import jalview.bin.Cache;
  26 import jalview.datamodel.SequenceFeature;
  27 import jalview.datamodel.SequenceI;
  28 import jalview.gui.Help.HelpId;
  29 import jalview.io.JalviewFileChooser;
  30 import jalview.io.JalviewFileView;
  31 import jalview.schemabinding.version2.JalviewUserColours;
  32 import jalview.schemes.FeatureColour;
  33 import jalview.util.Format;
  34 import jalview.util.MessageManager;
  35 import jalview.util.Platform;
  36 import jalview.util.QuickSort;
  37 import jalview.viewmodel.AlignmentViewport;
  38 import jalview.ws.dbsources.das.api.jalviewSourceI;
  39
  40 import java.awt.BorderLayout;
  41 import java.awt.Color;
  42 import java.awt.Component;
  43 import java.awt.Dimension;
  44 import java.awt.Font;
  45 import java.awt.Graphics;
  46 import java.awt.GridLayout;
  47 import java.awt.Rectangle;
  48 import java.awt.event.ActionEvent;
  49 import java.awt.event.ActionListener;
  50 import java.awt.event.ItemEvent;
  51 import java.awt.event.ItemListener;
  52 import java.awt.event.MouseAdapter;
  53 import java.awt.event.MouseEvent;
  54 import java.awt.event.MouseMotionAdapter;
  55 import java.beans.PropertyChangeEvent;
  56 import java.beans.PropertyChangeListener;
  57 import java.io.File;
  58 import java.io.FileInputStream;
  59 import java.io.FileOutputStream;
  60 import java.io.InputStreamReader;
  61 import java.io.OutputStreamWriter;
  62 import java.io.PrintWriter;
  63 import java.util.Arrays;
  64 import java.util.HashSet;
  65 import java.util.Hashtable;
  66 import java.util.Iterator;
  67 import java.util.List;
  68 import java.util.Map;
  69 import java.util.Set;
  70 import java.util.Vector;
  71
  72 import javax.help.HelpSetException;
  73 import javax.swing.AbstractCellEditor;
  74 import javax.swing.BorderFactory;
  75 import javax.swing.Icon;
  76 import javax.swing.JButton;
  77 import javax.swing.JCheckBox;
  78 import javax.swing.JCheckBoxMenuItem;
  79 import javax.swing.JColorChooser;
  80 import javax.swing.JDialog;
  81 import javax.swing.JInternalFrame;
  82 import javax.swing.JLabel;
  83 import javax.swing.JLayeredPane;
  84 import javax.swing.JMenuItem;
  85 import javax.swing.JPanel;
  86 import javax.swing.JPopupMenu;
  87 import javax.swing.JScrollPane;
  88 import javax.swing.JSlider;
  89 import javax.swing.JTabbedPane;
  90 import javax.swing.JTable;
  91 import javax.swing.ListSelectionModel;
  92 import javax.swing.SwingConstants;
  93 import javax.swing.SwingUtilities;
  94 import javax.swing.event.ChangeEvent;
  95 import javax.swing.event.ChangeListener;
  96 import javax.swing.table.AbstractTableModel;
  97 import javax.swing.table.TableCellEditor;
  98 import javax.swing.table.TableCellRenderer;
  99
 100 public class FeatureSettings extends JPanel implements
 101         FeatureSettingsControllerI
 102 {
 103   DasSourceBrowser dassourceBrowser;
 104
 105   jalview.ws.DasSequenceFeatureFetcher dasFeatureFetcher;
 106
 107   JPanel settingsPane = new JPanel();
 108
 109   JPanel dasSettingsPane = new JPanel();
 110
 111   final FeatureRenderer fr;
 112
 113   public final AlignFrame af;
 114
 115   Object[][] originalData;
 116
 117   private float originalTransparency;
 118
 119   final JInternalFrame frame;
 120
 121   JScrollPane scrollPane = new JScrollPane();
 122
 123   JTable table;
 124
 125   JPanel groupPanel;
 126
 127   JSlider transparency = new JSlider();
 128
 129   JPanel transPanel = new JPanel(new GridLayout(1, 2));
 130
 131   private static final int MIN_WIDTH = 400;
 132
 133   private static final int MIN_HEIGHT = 400;
 134
 135   /**
 136    * Constructor
 137    *
 138    * @param af
 139    */
 140   public FeatureSettings(AlignFrame af)
 141   {
 142     this.af = af;
 143     fr = af.getFeatureRenderer();
 144     // allow transparency to be recovered
 145     transparency.setMaximum(100 - (int) ((originalTransparency = fr
 146             .getTransparency()) * 100));
 147
 148     try
 149     {
 150       jbInit();
 151     } catch (Exception ex)
 152     {
 153       ex.printStackTrace();
 154     }
 155
 156     table = new JTable()
 157     {
 158       @Override
 159       public String getToolTipText(MouseEvent e)
 160       {
 161         if (table.columnAtPoint(e.getPoint()) == 0)
 162         {
 163           /*
 164            * Tooltip for feature name only
 165            */
 166           return JvSwingUtils.wrapTooltip(true, MessageManager
 167                   .getString("label.feature_settings_click_drag"));
 168         }
 169         return null;
 170       }
 171     };
 172     table.getTableHeader().setFont(new Font("Verdana", Font.PLAIN, 12));
 173     table.setFont(new Font("Verdana", Font.PLAIN, 12));
 174     table.setDefaultRenderer(Color.class, new ColorRenderer());
 175
 176     table.setDefaultEditor(Color.class, new ColorEditor(this));
 177
 178     table.setDefaultEditor(FeatureColour.class, new ColorEditor(this));
 179     table.setDefaultRenderer(FeatureColour.class, new ColorRenderer());
 180     table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 181
 182     table.addMouseListener(new MouseAdapter()
 183     {
 184       @Override
 185       public void mousePressed(MouseEvent evt)
 186       {
 187         selectedRow = table.rowAtPoint(evt.getPoint());
 188         if (evt.isPopupTrigger())
 189         {
 190           popupSort(selectedRow, (String) table.getValueAt(selectedRow, 0),
 191                   table.getValueAt(selectedRow, 1), fr.getMinMax(),
 192                   evt.getX(), evt.getY());
 193         }
 194         else if (evt.getClickCount() == 2)
 195         {
 196           boolean invertSelection = evt.isAltDown();
 197           boolean toggleSelection = Platform.isControlDown(evt);
 198           boolean extendSelection = evt.isShiftDown();
 199           fr.ap.alignFrame.avc.markColumnsContainingFeatures(
 200                   invertSelection, extendSelection, toggleSelection,
 201                   (String) table.getValueAt(selectedRow, 0));
 202         }
 203       }
 204
 205       // isPopupTrigger fires on mouseReleased on Windows
 206       @Override
 207       public void mouseReleased(MouseEvent evt)
 208       {
 209         selectedRow = table.rowAtPoint(evt.getPoint());
 210         if (evt.isPopupTrigger())
 211         {
 212           popupSort(selectedRow, (String) table.getValueAt(selectedRow, 0),
 213                   table.getValueAt(selectedRow, 1), fr.getMinMax(),
 214                   evt.getX(), evt.getY());
 215         }
 216       }
 217     });
 218
 219     table.addMouseMotionListener(new MouseMotionAdapter()
 220     {
 221       @Override
 222       public void mouseDragged(MouseEvent evt)
 223       {
 224         int newRow = table.rowAtPoint(evt.getPoint());
 225         if (newRow != selectedRow && selectedRow != -1 && newRow != -1)
 226         {
 227           /*
 228            * reposition 'selectedRow' to 'newRow' (the dragged to location)
 229            * this could be more than one row away for a very fast drag action
 230            * so just swap it with adjacent rows until we get it there
 231            */
 232           Object[][] data = ((FeatureTableModel) table.getModel())
 233                   .getData();
 234           int direction = newRow < selectedRow ? -1 : 1;
 235           for (int i = selectedRow; i != newRow; i += direction)
 236           {
 237             Object[] temp = data[i];
 238             data[i] = data[i + direction];
 239             data[i + direction] = temp;
 240           }
 241           updateFeatureRenderer(data);
 242           table.repaint();
 243           selectedRow = newRow;
 244         }
 245       }
 246     });
 247     // table.setToolTipText(JvSwingUtils.wrapTooltip(true,
 248     // MessageManager.getString("label.feature_settings_click_drag")));
 249     scrollPane.setViewportView(table);
 250
 251     dassourceBrowser = new DasSourceBrowser(this);
 252     dasSettingsPane.add(dassourceBrowser, BorderLayout.CENTER);
 253
 254     if (af.getViewport().isShowSequenceFeatures() || !fr.hasRenderOrder())
 255     {
 256       fr.findAllFeatures(true); // display everything!
 257     }
 258
 259     discoverAllFeatureData();
 260     final PropertyChangeListener change;
 261     final FeatureSettings fs = this;
 262     fr.addPropertyChangeListener(change = new PropertyChangeListener()
 263     {
 264       @Override
 265       public void propertyChange(PropertyChangeEvent evt)
 266       {
 267         if (!fs.resettingTable && !fs.handlingUpdate)
 268         {
 269           fs.handlingUpdate = true;
 270           fs.resetTable(null); // new groups may be added with new seuqence
 271           // feature types only
 272           fs.handlingUpdate = false;
 273         }
 274       }
 275
 276     });
 277
 278     frame = new JInternalFrame();
 279     frame.setContentPane(this);
 280     if (Platform.isAMac())
 281     {
 282       Desktop.addInternalFrame(frame,
 283               MessageManager.getString("label.sequence_feature_settings"),
 284               475, 480);
 285     }
 286     else
 287     {
 288       Desktop.addInternalFrame(frame,
 289               MessageManager.getString("label.sequence_feature_settings"),
 290               400, 450);
 291     }
 292     frame.setMinimumSize(new Dimension(MIN_WIDTH, MIN_HEIGHT));
 293
 294     frame.addInternalFrameListener(new javax.swing.event.InternalFrameAdapter()
 295     {
 296       @Override
 297       public void internalFrameClosed(
 298               javax.swing.event.InternalFrameEvent evt)
 299       {
 300         fr.removePropertyChangeListener(change);
 301         dassourceBrowser.fs = null;
 302       };
 303     });
 304     frame.setLayer(JLayeredPane.PALETTE_LAYER);
 305   }
 306
 307   protected void popupSort(final int selectedRow, final String type,
 308           final Object typeCol, final Map<String, float[][]> minmax, int x,
 309           int y)
 310   {
 311     final FeatureColourI featureColour = (FeatureColourI) typeCol;
 312
 313     JPopupMenu men = new JPopupMenu(MessageManager.formatMessage(
 314             "label.settings_for_param", new String[] { type }));
 315     JMenuItem scr = new JMenuItem(
 316             MessageManager.getString("label.sort_by_score"));
 317     men.add(scr);
 318     final FeatureSettings me = this;
 319     scr.addActionListener(new ActionListener()
 320     {
 321
 322       @Override
 323       public void actionPerformed(ActionEvent e)
 324       {
 325         me.af.avc.sortAlignmentByFeatureScore(Arrays
 326                 .asList(new String[] { type }));
 327       }
 328
 329     });
 330     JMenuItem dens = new JMenuItem(
 331             MessageManager.getString("label.sort_by_density"));
 332     dens.addActionListener(new ActionListener()
 333     {
 334
 335       @Override
 336       public void actionPerformed(ActionEvent e)
 337       {
 338         me.af.avc.sortAlignmentByFeatureDensity(Arrays
 339                 .asList(new String[] { type }));
 340       }
 341
 342     });
 343     men.add(dens);
 344     if (minmax != null)
 345     {
 346       final float[][] typeMinMax = minmax.get(type);
 347       /*
 348        * final JCheckBoxMenuItem chb = new JCheckBoxMenuItem("Vary Height"); //
 349        * this is broken at the moment and isn't that useful anyway!
 350        * chb.setSelected(minmax.get(type) != null); chb.addActionListener(new
 351        * ActionListener() {
 352        *
 353        * public void actionPerformed(ActionEvent e) {
 354        * chb.setState(chb.getState()); if (chb.getState()) { minmax.put(type,
 355        * null); } else { minmax.put(type, typeMinMax); } }
 356        *
 357        * });
 358        *
 359        * men.add(chb);
 360        */
 361       if (typeMinMax != null && typeMinMax[0] != null)
 362       {
 363         // if (table.getValueAt(row, column));
 364         // graduated colourschemes for those where minmax exists for the
 365         // positional features
 366         final JCheckBoxMenuItem mxcol = new JCheckBoxMenuItem(
 367                 "Graduated Colour");
 368         mxcol.setSelected(!featureColour.isSimpleColour());
 369         men.add(mxcol);
 370         mxcol.addActionListener(new ActionListener()
 371         {
 372           JColorChooser colorChooser;
 373
 374           @Override
 375           public void actionPerformed(ActionEvent e)
 376           {
 377             if (e.getSource() == mxcol)
 378             {
 379               if (featureColour.isSimpleColour())
 380               {
 381                 FeatureColourChooser fc = new FeatureColourChooser(me.fr,
 382                         type);
 383                 fc.addActionListener(this);
 384               }
 385               else
 386               {
 387                 // bring up simple color chooser
 388                 colorChooser = new JColorChooser();
 389                 JDialog dialog = JColorChooser.createDialog(me,
 390                         "Select new Colour", true, // modal
 391                         colorChooser, this, // OK button handler
 392                         null); // no CANCEL button handler
 393                 colorChooser.setColor(featureColour.getMaxColour());
 394                 dialog.setVisible(true);
 395               }
 396             }
 397             else
 398             {
 399               if (e.getSource() instanceof FeatureColourChooser)
 400               {
 401                 FeatureColourChooser fc = (FeatureColourChooser) e
 402                         .getSource();
 403                 table.setValueAt(fc.getLastColour(), selectedRow, 1);
 404                 table.validate();
 405               }
 406               else
 407               {
 408                 // probably the color chooser!
 409                 table.setValueAt(
 410                         new FeatureColour(colorChooser.getColor()),
 411                         selectedRow, 1);
 412                 table.validate();
 413                 me.updateFeatureRenderer(
 414                         ((FeatureTableModel) table.getModel()).getData(),
 415                         false);
 416               }
 417             }
 418           }
 419
 420         });
 421       }
 422     }
 423     JMenuItem selCols = new JMenuItem(
 424             MessageManager.getString("label.select_columns_containing"));
 425     selCols.addActionListener(new ActionListener()
 426     {
 427       @Override
 428       public void actionPerformed(ActionEvent arg0)
 429       {
 430         fr.ap.alignFrame.avc.markColumnsContainingFeatures(false, false,
 431                 false, type);
 432       }
 433     });
 434     JMenuItem clearCols = new JMenuItem(
 435             MessageManager.getString("label.select_columns_not_containing"));
 436     clearCols.addActionListener(new ActionListener()
 437     {
 438       @Override
 439       public void actionPerformed(ActionEvent arg0)
 440       {
 441         fr.ap.alignFrame.avc.markColumnsContainingFeatures(true, false,
 442                 false, type);
 443       }
 444     });
 445     JMenuItem hideCols = new JMenuItem(
 446             MessageManager.getString("label.hide_columns_containing"));
 447     hideCols.addActionListener(new ActionListener()
 448     {
 449       @Override
 450       public void actionPerformed(ActionEvent arg0)
 451       {
 452         fr.ap.alignFrame.hideFeatureColumns(type, true);
 453       }
 454     });
 455     JMenuItem hideOtherCols = new JMenuItem(
 456             MessageManager.getString("label.hide_columns_not_containing"));
 457     hideOtherCols.addActionListener(new ActionListener()
 458     {
 459       @Override
 460       public void actionPerformed(ActionEvent arg0)
 461       {
 462         fr.ap.alignFrame.hideFeatureColumns(type, false);
 463       }
 464     });
 465     men.add(selCols);
 466     men.add(clearCols);
 467     men.add(hideCols);
 468     men.add(hideOtherCols);
 469     men.show(table, x, y);
 470   }
 471
 472   /**
 473    * true when Feature Settings are updating from feature renderer
 474    */
 475   private boolean handlingUpdate = false;
 476
 477   /**
 478    * contains a float[3] for each feature type string. created by setTableData
 479    */
 480   Map<String, float[]> typeWidth = null;
 481
 482   @Override
 483   synchronized public void discoverAllFeatureData()
 484   {
 485     Vector<String> allFeatures = new Vector<String>();
 486     Vector<String> allGroups = new Vector<String>();
 487     SequenceFeature[] tmpfeatures;
 488     String group;
 489     for (int i = 0; i < af.getViewport().getAlignment().getHeight(); i++)
 490     {
 491       tmpfeatures = af.getViewport().getAlignment().getSequenceAt(i)
 492               .getSequenceFeatures();
 493       if (tmpfeatures == null)
 494       {
 495         continue;
 496       }
 497
 498       int index = 0;
 499       while (index < tmpfeatures.length)
 500       {
 501         if (tmpfeatures[index].begin == 0 && tmpfeatures[index].end == 0)
 502         {
 503           index++;
 504           continue;
 505         }
 506
 507         if (tmpfeatures[index].getFeatureGroup() != null)
 508         {
 509           group = tmpfeatures[index].featureGroup;
 510           if (!allGroups.contains(group))
 511           {
 512             allGroups.addElement(group);
 513             checkGroupState(group);
 514           }
 515         }
 516
 517         if (!allFeatures.contains(tmpfeatures[index].getType()))
 518         {
 519           allFeatures.addElement(tmpfeatures[index].getType());
 520         }
 521         index++;
 522       }
 523     }
 524
 525     resetTable(null);
 526
 527     validate();
 528   }
 529
 530   /**
 531    * Synchronise gui group list and check visibility of group
 532    *
 533    * @param group
 534    * @return true if group is visible
 535    */
 536   private boolean checkGroupState(String group)
 537   {
 538     boolean visible = fr.checkGroupVisibility(group, true);
 539
 540     for (int g = 0; g < groupPanel.getComponentCount(); g++)
 541     {
 542       if (((JCheckBox) groupPanel.getComponent(g)).getText().equals(group))
 543       {
 544         ((JCheckBox) groupPanel.getComponent(g)).setSelected(visible);
 545         return visible;
 546       }
 547     }
 548
 549     final String grp = group;
 550     final JCheckBox check = new JCheckBox(group, visible);
 551     check.setFont(new Font("Serif", Font.BOLD, 12));
 552     check.addItemListener(new ItemListener()
 553     {
 554       @Override
 555       public void itemStateChanged(ItemEvent evt)
 556       {
 557         fr.setGroupVisibility(check.getText(), check.isSelected());
 558         af.alignPanel.getSeqPanel().seqCanvas.repaint();
 559         if (af.alignPanel.overviewPanel != null)
 560         {
 561           af.alignPanel.overviewPanel.updateOverviewImage();
 562         }
 563
 564         resetTable(new String[] { grp });
 565       }
 566     });
 567     groupPanel.add(check);
 568     return visible;
 569   }
 570
 571   boolean resettingTable = false;
 572
 573   synchronized void resetTable(String[] groupChanged)
 574   {
 575     if (resettingTable == true)
 576     {
 577       return;
 578     }
 579     resettingTable = true;
 580     typeWidth = new Hashtable<String, float[]>();
 581     // TODO: change avWidth calculation to 'per-sequence' average and use long
 582     // rather than float
 583     float[] avWidth = null;
 584     SequenceFeature[] tmpfeatures;
 585     String group = null, type;
 586     Vector<String> visibleChecks = new Vector<String>();
 587     Set<String> foundGroups = new HashSet<String>();
 588
 589     // Find out which features should be visible depending on which groups
 590     // are selected / deselected
 591     // and recompute average width ordering
 592     for (int i = 0; i < af.getViewport().getAlignment().getHeight(); i++)
 593     {
 594
 595       tmpfeatures = af.getViewport().getAlignment().getSequenceAt(i)
 596               .getSequenceFeatures();
 597       if (tmpfeatures == null)
 598       {
 599         continue;
 600       }
 601
 602       int index = 0;
 603       while (index < tmpfeatures.length)
 604       {
 605         group = tmpfeatures[index].featureGroup;
 606         foundGroups.add(group);
 607
 608         if (tmpfeatures[index].begin == 0 && tmpfeatures[index].end == 0)
 609         {
 610           index++;
 611           continue;
 612         }
 613
 614         if (group == null || checkGroupState(group))
 615         {
 616           type = tmpfeatures[index].getType();
 617           if (!visibleChecks.contains(type))
 618           {
 619             visibleChecks.addElement(type);
 620           }
 621         }
 622         if (!typeWidth.containsKey(tmpfeatures[index].getType()))
 623         {
 624           typeWidth.put(tmpfeatures[index].getType(),
 625                   avWidth = new float[3]);
 626         }
 627         else
 628         {
 629           avWidth = typeWidth.get(tmpfeatures[index].getType());
 630         }
 631         avWidth[0]++;
 632         if (tmpfeatures[index].getBegin() > tmpfeatures[index].getEnd())
 633         {
 634           avWidth[1] += 1 + tmpfeatures[index].getBegin()
 635                   - tmpfeatures[index].getEnd();
 636         }
 637         else
 638         {
 639           avWidth[1] += 1 + tmpfeatures[index].getEnd()
 640                   - tmpfeatures[index].getBegin();
 641         }
 642         index++;
 643       }
 644     }
 645
 646     int fSize = visibleChecks.size();
 647     Object[][] data = new Object[fSize][3];
 648     int dataIndex = 0;
 649
 650     if (fr.hasRenderOrder())
 651     {
 652       if (!handlingUpdate)
 653       {
 654         fr.findAllFeatures(groupChanged != null); // prod to update
 655         // colourschemes. but don't
 656         // affect display
 657         // First add the checks in the previous render order,
 658         // in case the window has been closed and reopened
 659       }
 660       List<String> frl = fr.getRenderOrder();
 661       for (int ro = frl.size() - 1; ro > -1; ro--)
 662       {
 663         type = frl.get(ro);
 664
 665         if (!visibleChecks.contains(type))
 666         {
 667           continue;
 668         }
 669
 670         data[dataIndex][0] = type;
 671         data[dataIndex][1] = fr.getFeatureStyle(type);
 672         data[dataIndex][2] = new Boolean(af.getViewport()
 673                 .getFeaturesDisplayed().isVisible(type));
 674         dataIndex++;
 675         visibleChecks.removeElement(type);
 676       }
 677     }
 678
 679     fSize = visibleChecks.size();
 680     for (int i = 0; i < fSize; i++)
 681     {
 682       // These must be extra features belonging to the group
 683       // which was just selected
 684       type = visibleChecks.elementAt(i).toString();
 685       data[dataIndex][0] = type;
 686
 687       data[dataIndex][1] = fr.getFeatureStyle(type);
 688       if (data[dataIndex][1] == null)
 689       {
 690         // "Colour has been updated in another view!!"
 691         fr.clearRenderOrder();
 692         return;
 693       }
 694
 695       data[dataIndex][2] = new Boolean(true);
 696       dataIndex++;
 697     }
 698
 699     if (originalData == null)
 700     {
 701       originalData = new Object[data.length][3];
 702       for (int i = 0; i < data.length; i++)
 703       {
 704         System.arraycopy(data[i], 0, originalData[i], 0, 3);
 705       }
 706     }
 707
 708     table.setModel(new FeatureTableModel(data));
 709     table.getColumnModel().getColumn(0).setPreferredWidth(200);
 710
 711     groupPanel.setLayout(new GridLayout(fr.getFeatureGroupsSize() / 4 + 1,
 712             4));
 713     pruneGroups(foundGroups);
 714     groupPanel.validate();
 715
 716     updateFeatureRenderer(data, groupChanged != null);
 717     resettingTable = false;
 718   }
 719
 720   /**
 721    * Remove from the groups panel any checkboxes for groups that are not in the
 722    * foundGroups set. This enables removing a group from the display when the
 723    * last feature in that group is deleted.
 724    *
 725    * @param foundGroups
 726    */
 727   protected void pruneGroups(Set<String> foundGroups)
 728   {
 729     for (int g = 0; g < groupPanel.getComponentCount(); g++)
 730     {
 731       JCheckBox checkbox = (JCheckBox) groupPanel.getComponent(g);
 732       if (!foundGroups.contains(checkbox.getText()))
 733       {
 734         groupPanel.remove(checkbox);
 735       }
 736     }
 737   }
 738
 739   /**
 740    * reorder data based on the featureRenderers global priority list.
 741    *
 742    * @param data
 743    */
 744   private void ensureOrder(Object[][] data)
 745   {
 746     boolean sort = false;
 747     float[] order = new float[data.length];
 748     for (int i = 0; i < order.length; i++)
 749     {
 750       order[i] = fr.getOrder(data[i][0].toString());
 751       if (order[i] < 0)
 752       {
 753         order[i] = fr.setOrder(data[i][0].toString(), i / order.length);
 754       }
 755       if (i > 1)
 756       {
 757         sort = sort || order[i - 1] > order[i];
 758       }
 759     }
 760     if (sort)
 761     {
 762       jalview.util.QuickSort.sort(order, data);
 763     }
 764   }
 765
 766   void load()
 767   {
 768     JalviewFileChooser chooser = new JalviewFileChooser("fc",
 769             "Sequence Feature Colours");
 770     chooser.setFileView(new JalviewFileView());
 771     chooser.setDialogTitle(MessageManager
 772             .getString("label.load_feature_colours"));
 773     chooser.setToolTipText(MessageManager.getString("action.load"));
 774
 775     int value = chooser.showOpenDialog(this);
 776
 777     if (value == JalviewFileChooser.APPROVE_OPTION)
 778     {
 779       File file = chooser.getSelectedFile();
 780
 781       try
 782       {
 783         InputStreamReader in = new InputStreamReader(new FileInputStream(
 784                 file), "UTF-8");
 785
 786         JalviewUserColours jucs = JalviewUserColours.unmarshal(in);
 787
 788         for (int i = jucs.getColourCount() - 1; i >= 0; i--)
 789         {
 790           String name;
 791           jalview.schemabinding.version2.Colour newcol = jucs.getColour(i);
 792           if (newcol.hasMax())
 793           {
 794             Color mincol = null, maxcol = null;
 795             try
 796             {
 797               mincol = new Color(Integer.parseInt(newcol.getMinRGB(), 16));
 798               maxcol = new Color(Integer.parseInt(newcol.getRGB(), 16));
 799
 800             } catch (Exception e)
 801             {
 802               Cache.log.warn("Couldn't parse out graduated feature color.",
 803                       e);
 804             }
 805             FeatureColourI gcol = new FeatureColour(mincol, maxcol,
 806                     newcol.getMin(), newcol.getMax());
 807             if (newcol.hasAutoScale())
 808             {
 809               gcol.setAutoScaled(newcol.getAutoScale());
 810             }
 811             if (newcol.hasColourByLabel())
 812             {
 813               gcol.setColourByLabel(newcol.getColourByLabel());
 814             }
 815             if (newcol.hasThreshold())
 816             {
 817               gcol.setThreshold(newcol.getThreshold());
 818             }
 819             if (newcol.getThreshType().length() > 0)
 820             {
 821               String ttyp = newcol.getThreshType();
 822               if (ttyp.equalsIgnoreCase("ABOVE"))
 823               {
 824                 gcol.setAboveThreshold(true);
 825               }
 826               if (ttyp.equalsIgnoreCase("BELOW"))
 827               {
 828                 gcol.setBelowThreshold(true);
 829               }
 830             }
 831             fr.setColour(name = newcol.getName(), gcol);
 832           }
 833           else
 834           {
 835             Color color = new Color(
 836                     Integer.parseInt(jucs.getColour(i).getRGB(), 16));
 837             fr.setColour(name = jucs.getColour(i).getName(),
 838                     new FeatureColour(color));
 839           }
 840           fr.setOrder(name, (i == 0) ? 0 : i / jucs.getColourCount());
 841         }
 842         if (table != null)
 843         {
 844           resetTable(null);
 845           Object[][] data = ((FeatureTableModel) table.getModel())
 846                   .getData();
 847           ensureOrder(data);
 848           updateFeatureRenderer(data, false);
 849           table.repaint();
 850         }
 851       } catch (Exception ex)
 852       {
 853         System.out.println("Error loading User Colour File\n" + ex);
 854       }
 855     }
 856   }
 857
 858   void save()
 859   {
 860     JalviewFileChooser chooser = new JalviewFileChooser("fc",
 861             "Sequence Feature Colours");
 862     chooser.setFileView(new JalviewFileView());
 863     chooser.setDialogTitle(MessageManager
 864             .getString("label.save_feature_colours"));
 865     chooser.setToolTipText(MessageManager.getString("action.save"));
 866
 867     int value = chooser.showSaveDialog(this);
 868
 869     if (value == JalviewFileChooser.APPROVE_OPTION)
 870     {
 871       String choice = chooser.getSelectedFile().getPath();
 872       jalview.schemabinding.version2.JalviewUserColours ucs = new jalview.schemabinding.version2.JalviewUserColours();
 873       ucs.setSchemeName("Sequence Features");
 874       try
 875       {
 876         PrintWriter out = new PrintWriter(new OutputStreamWriter(
 877                 new FileOutputStream(choice), "UTF-8"));
 878
 879         Set<String> fr_colours = fr.getAllFeatureColours();
 880         Iterator<String> e = fr_colours.iterator();
 881         float[] sortOrder = new float[fr_colours.size()];
 882         String[] sortTypes = new String[fr_colours.size()];
 883         int i = 0;
 884         while (e.hasNext())
 885         {
 886           sortTypes[i] = e.next();
 887           sortOrder[i] = fr.getOrder(sortTypes[i]);
 888           i++;
 889         }
 890         QuickSort.sort(sortOrder, sortTypes);
 891         sortOrder = null;
 892         for (i = 0; i < sortTypes.length; i++)
 893         {
 894           jalview.schemabinding.version2.Colour col = new jalview.schemabinding.version2.Colour();
 895           col.setName(sortTypes[i]);
 896           FeatureColourI fcol = fr.getFeatureStyle(sortTypes[i]);
 897           if (fcol.isSimpleColour())
 898           {
 899             col.setRGB(Format.getHexString(fcol.getColour()));
 900           }
 901           else
 902           {
 903             col.setRGB(Format.getHexString(fcol.getMaxColour()));
 904             col.setMin(fcol.getMin());
 905             col.setMax(fcol.getMax());
 906             col.setMinRGB(jalview.util.Format.getHexString(fcol
 907                     .getMinColour()));
 908             col.setAutoScale(fcol.isAutoScaled());
 909             col.setThreshold(fcol.getThreshold());
 910             col.setColourByLabel(fcol.isColourByLabel());
 911             col.setThreshType(fcol.isAboveThreshold() ? "ABOVE" : (fcol
 912                     .isBelowThreshold() ? "BELOW" : "NONE"));
 913           }
 914           ucs.addColour(col);
 915         }
 916         ucs.marshal(out);
 917         out.close();
 918       } catch (Exception ex)
 919       {
 920         ex.printStackTrace();
 921       }
 922     }
 923   }
 924
 925   public void invertSelection()
 926   {
 927     for (int i = 0; i < table.getRowCount(); i++)
 928     {
 929       Boolean value = (Boolean) table.getValueAt(i, 2);
 930
 931       table.setValueAt(new Boolean(!value.booleanValue()), i, 2);
 932     }
 933   }
 934
 935   public void orderByAvWidth()
 936   {
 937     if (table == null || table.getModel() == null)
 938     {
 939       return;
 940     }
 941     Object[][] data = ((FeatureTableModel) table.getModel()).getData();
 942     float[] width = new float[data.length];
 943     float[] awidth;
 944     float max = 0;
 945     int num = 0;
 946     for (int i = 0; i < data.length; i++)
 947     {
 948       awidth = typeWidth.get(data[i][0]);
 949       if (awidth[0] > 0)
 950       {
 951         width[i] = awidth[1] / awidth[0];// *awidth[0]*awidth[2]; - better
 952         // weight - but have to make per
 953         // sequence, too (awidth[2])
 954         // if (width[i]==1) // hack to distinguish single width sequences.
 955         num++;
 956       }
 957       else
 958       {
 959         width[i] = 0;
 960       }
 961       if (max < width[i])
 962       {
 963         max = width[i];
 964       }
 965     }
 966     boolean sort = false;
 967     for (int i = 0; i < width.length; i++)
 968     {
 969       // awidth = (float[]) typeWidth.get(data[i][0]);
 970       if (width[i] == 0)
 971       {
 972         width[i] = fr.getOrder(data[i][0].toString());
 973         if (width[i] < 0)
 974         {
 975           width[i] = fr.setOrder(data[i][0].toString(), i / data.length);
 976         }
 977       }
 978       else
 979       {
 980         width[i] /= max; // normalize
 981         fr.setOrder(data[i][0].toString(), width[i]); // store for later
 982       }
 983       if (i > 0)
 984       {
 985         sort = sort || width[i - 1] > width[i];
 986       }
 987     }
 988     if (sort)
 989     {
 990       jalview.util.QuickSort.sort(width, data);
 991       // update global priority order
 992     }
 993
 994     updateFeatureRenderer(data, false);
 995     table.repaint();
 996   }
 997
 998   public void close()
 999   {
1000     try
1001     {
1002       frame.setClosed(true);
1003     } catch (Exception exe)
1004     {
1005     }
1006
1007   }
1008
1009   public void updateFeatureRenderer(Object[][] data)
1010   {
1011     updateFeatureRenderer(data, true);
1012   }
1013
1014   /**
1015    * Update the priority order of features; only repaint if this changed the
1016    * order of visible features
1017    *
1018    * @param data
1019    * @param visibleNew
1020    */
1021   private void updateFeatureRenderer(Object[][] data, boolean visibleNew)
1022   {
1023     if (fr.setFeaturePriority(data, visibleNew))
1024     {
1025       af.alignPanel.paintAlignment(true);
1026     }
1027   }
1028
1029   int selectedRow = -1;
1030
1031   JTabbedPane tabbedPane = new JTabbedPane();
1032
1033   BorderLayout borderLayout1 = new BorderLayout();
1034
1035   BorderLayout borderLayout2 = new BorderLayout();
1036
1037   BorderLayout borderLayout3 = new BorderLayout();
1038
1039   JPanel bigPanel = new JPanel();
1040
1041   BorderLayout borderLayout4 = new BorderLayout();
1042
1043   JButton invert = new JButton();
1044
1045   JPanel buttonPanel = new JPanel();
1046
1047   JButton cancel = new JButton();
1048
1049   JButton ok = new JButton();
1050
1051   JButton loadColours = new JButton();
1052
1053   JButton saveColours = new JButton();
1054
1055   JPanel dasButtonPanel = new JPanel();
1056
1057   JButton fetchDAS = new JButton();
1058
1059   JButton saveDAS = new JButton();
1060
1061   JButton cancelDAS = new JButton();
1062
1063   JButton optimizeOrder = new JButton();
1064
1065   JButton sortByScore = new JButton();
1066
1067   JButton sortByDens = new JButton();
1068
1069   JButton help = new JButton();
1070
1071   JPanel transbuttons = new JPanel(new GridLayout(5, 1));
1072
1073   private void jbInit() throws Exception
1074   {
1075     this.setLayout(borderLayout1);
1076     settingsPane.setLayout(borderLayout2);
1077     dasSettingsPane.setLayout(borderLayout3);
1078     bigPanel.setLayout(borderLayout4);
1079
1080     groupPanel = new JPanel();
1081     bigPanel.add(groupPanel, BorderLayout.NORTH);
1082
1083     invert.setFont(JvSwingUtils.getLabelFont());
1084     invert.setText(MessageManager.getString("label.invert_selection"));
1085     invert.addActionListener(new ActionListener()
1086     {
1087       @Override
1088       public void actionPerformed(ActionEvent e)
1089       {
1090         invertSelection();
1091       }
1092     });
1093     optimizeOrder.setFont(JvSwingUtils.getLabelFont());
1094     optimizeOrder.setText(MessageManager.getString("label.optimise_order"));
1095     optimizeOrder.addActionListener(new ActionListener()
1096     {
1097       @Override
1098       public void actionPerformed(ActionEvent e)
1099       {
1100         orderByAvWidth();
1101       }
1102     });
1103     sortByScore.setFont(JvSwingUtils.getLabelFont());
1104     sortByScore
1105             .setText(MessageManager.getString("label.seq_sort_by_score"));
1106     sortByScore.addActionListener(new ActionListener()
1107     {
1108       @Override
1109       public void actionPerformed(ActionEvent e)
1110       {
1111         af.avc.sortAlignmentByFeatureScore(null);
1112       }
1113     });
1114     sortByDens.setFont(JvSwingUtils.getLabelFont());
1115     sortByDens.setText(MessageManager
1116             .getString("label.sequence_sort_by_density"));
1117     sortByDens.addActionListener(new ActionListener()
1118     {
1119       @Override
1120       public void actionPerformed(ActionEvent e)
1121       {
1122         af.avc.sortAlignmentByFeatureDensity(null);
1123       }
1124     });
1125     help.setFont(JvSwingUtils.getLabelFont());
1126     help.setText(MessageManager.getString("action.help"));
1127     help.addActionListener(new ActionListener()
1128     {
1129       @Override
1130       public void actionPerformed(ActionEvent e)
1131       {
1132         try
1133         {
1134           Help.showHelpWindow(HelpId.SequenceFeatureSettings);
1135         } catch (HelpSetException e1)
1136         {
1137           e1.printStackTrace();
1138         }
1139       }
1140     });
1141     help.setFont(JvSwingUtils.getLabelFont());
1142     help.setText(MessageManager.getString("action.help"));
1143     help.addActionListener(new ActionListener()
1144     {
1145       @Override
1146       public void actionPerformed(ActionEvent e)
1147       {
1148         try
1149         {
1150           Help.showHelpWindow(HelpId.SequenceFeatureSettings);
1151         } catch (HelpSetException e1)
1152         {
1153           e1.printStackTrace();
1154         }
1155       }
1156     });
1157     cancel.setFont(JvSwingUtils.getLabelFont());
1158     cancel.setText(MessageManager.getString("action.cancel"));
1159     cancel.addActionListener(new ActionListener()
1160     {
1161       @Override
1162       public void actionPerformed(ActionEvent e)
1163       {
1164         fr.setTransparency(originalTransparency);
1165         updateFeatureRenderer(originalData);
1166         close();
1167       }
1168     });
1169     ok.setFont(JvSwingUtils.getLabelFont());
1170     ok.setText(MessageManager.getString("action.ok"));
1171     ok.addActionListener(new ActionListener()
1172     {
1173       @Override
1174       public void actionPerformed(ActionEvent e)
1175       {
1176         close();
1177       }
1178     });
1179     loadColours.setFont(JvSwingUtils.getLabelFont());
1180     loadColours.setText(MessageManager.getString("label.load_colours"));
1181     loadColours.addActionListener(new ActionListener()
1182     {
1183       @Override
1184       public void actionPerformed(ActionEvent e)
1185       {
1186         load();
1187       }
1188     });
1189     saveColours.setFont(JvSwingUtils.getLabelFont());
1190     saveColours.setText(MessageManager.getString("label.save_colours"));
1191     saveColours.addActionListener(new ActionListener()
1192     {
1193       @Override
1194       public void actionPerformed(ActionEvent e)
1195       {
1196         save();
1197       }
1198     });
1199     transparency.addChangeListener(new ChangeListener()
1200     {
1201       @Override
1202       public void stateChanged(ChangeEvent evt)
1203       {
1204         fr.setTransparency((100 - transparency.getValue()) / 100f);
1205         af.alignPanel.paintAlignment(true);
1206       }
1207     });
1208
1209     transparency.setMaximum(70);
1210     transparency.setToolTipText(MessageManager
1211             .getString("label.transparency_tip"));
1212     fetchDAS.setText(MessageManager.getString("label.fetch_das_features"));
1213     fetchDAS.addActionListener(new ActionListener()
1214     {
1215       @Override
1216       public void actionPerformed(ActionEvent e)
1217       {
1218         fetchDAS_actionPerformed(e);
1219       }
1220     });
1221     saveDAS.setText(MessageManager.getString("action.save_as_default"));
1222     saveDAS.addActionListener(new ActionListener()
1223     {
1224       @Override
1225       public void actionPerformed(ActionEvent e)
1226       {
1227         saveDAS_actionPerformed(e);
1228       }
1229     });
1230     dasButtonPanel.setBorder(BorderFactory.createEtchedBorder());
1231     dasSettingsPane.setBorder(null);
1232     cancelDAS.setEnabled(false);
1233     cancelDAS.setText(MessageManager.getString("action.cancel_fetch"));
1234     cancelDAS.addActionListener(new ActionListener()
1235     {
1236       @Override
1237       public void actionPerformed(ActionEvent e)
1238       {
1239         cancelDAS_actionPerformed(e);
1240       }
1241     });
1242     this.add(tabbedPane, java.awt.BorderLayout.CENTER);
1243     tabbedPane.addTab(MessageManager.getString("label.feature_settings"),
1244             settingsPane);
1245     tabbedPane.addTab(MessageManager.getString("label.das_settings"),
1246             dasSettingsPane);
1247     bigPanel.add(transPanel, java.awt.BorderLayout.SOUTH);
1248     transbuttons.add(optimizeOrder);
1249     transbuttons.add(invert);
1250     transbuttons.add(sortByScore);
1251     transbuttons.add(sortByDens);
1252     transbuttons.add(help);
1253     JPanel sliderPanel = new JPanel();
1254     sliderPanel.add(transparency);
1255     transPanel.add(transparency);
1256     transPanel.add(transbuttons);
1257     buttonPanel.add(ok);
1258     buttonPanel.add(cancel);
1259     buttonPanel.add(loadColours);
1260     buttonPanel.add(saveColours);
1261     bigPanel.add(scrollPane, java.awt.BorderLayout.CENTER);
1262     dasSettingsPane.add(dasButtonPanel, java.awt.BorderLayout.SOUTH);
1263     dasButtonPanel.add(fetchDAS);
1264     dasButtonPanel.add(cancelDAS);
1265     dasButtonPanel.add(saveDAS);
1266     settingsPane.add(bigPanel, java.awt.BorderLayout.CENTER);
1267     settingsPane.add(buttonPanel, java.awt.BorderLayout.SOUTH);
1268   }
1269
1270   public void fetchDAS_actionPerformed(ActionEvent e)
1271   {
1272     fetchDAS.setEnabled(false);
1273     cancelDAS.setEnabled(true);
1274     dassourceBrowser.setGuiEnabled(false);
1275     Vector<jalviewSourceI> selectedSources = dassourceBrowser
1276             .getSelectedSources();
1277     doDasFeatureFetch(selectedSources, true, true);
1278   }
1279
1280   /**
1281    * get the features from selectedSources for all or the current selection
1282    *
1283    * @param selectedSources
1284    * @param checkDbRefs
1285    * @param promptFetchDbRefs
1286    */
1287   private void doDasFeatureFetch(List<jalviewSourceI> selectedSources,
1288           boolean checkDbRefs, boolean promptFetchDbRefs)
1289   {
1290     SequenceI[] dataset, seqs;
1291     int iSize;
1292     AlignmentViewport vp = af.getViewport();
1293     if (vp.getSelectionGroup() != null
1294             && vp.getSelectionGroup().getSize() > 0)
1295     {
1296       iSize = vp.getSelectionGroup().getSize();
1297       dataset = new SequenceI[iSize];
1298       seqs = vp.getSelectionGroup().getSequencesInOrder(vp.getAlignment());
1299     }
1300     else
1301     {
1302       iSize = vp.getAlignment().getHeight();
1303       seqs = vp.getAlignment().getSequencesArray();
1304     }
1305
1306     dataset = new SequenceI[iSize];
1307     for (int i = 0; i < iSize; i++)
1308     {
1309       dataset[i] = seqs[i].getDatasetSequence();
1310     }
1311
1312     cancelDAS.setEnabled(true);
1313     dasFeatureFetcher = new jalview.ws.DasSequenceFeatureFetcher(dataset,
1314             this, selectedSources, checkDbRefs, promptFetchDbRefs);
1315     af.getViewport().setShowSequenceFeatures(true);
1316     af.showSeqFeatures.setSelected(true);
1317   }
1318
1319   /**
1320    * blocking call to initialise the das source browser
1321    */
1322   public void initDasSources()
1323   {
1324     dassourceBrowser.initDasSources();
1325   }
1326
1327   /**
1328    * examine the current list of das sources and return any matching the given
1329    * nicknames in sources
1330    *
1331    * @param sources
1332    *          Vector of Strings to resolve to DAS source nicknames.
1333    * @return sources that are present in source list.
1334    */
1335   public List<jalviewSourceI> resolveSourceNicknames(Vector<String> sources)
1336   {
1337     return dassourceBrowser.sourceRegistry.resolveSourceNicknames(sources);
1338   }
1339
1340   /**
1341    * get currently selected das sources. ensure you have called initDasSources
1342    * before calling this.
1343    *
1344    * @return vector of selected das source nicknames
1345    */
1346   public Vector<jalviewSourceI> getSelectedSources()
1347   {
1348     return dassourceBrowser.getSelectedSources();
1349   }
1350
1351   /**
1352    * properly initialise DAS fetcher and then initiate a new thread to fetch
1353    * features from the named sources (rather than any turned on by default)
1354    *
1355    * @param sources
1356    * @param block
1357    *          if true then runs in same thread, otherwise passes to the Swing
1358    *          executor
1359    */
1360   public void fetchDasFeatures(Vector<String> sources, boolean block)
1361   {
1362     initDasSources();
1363     List<jalviewSourceI> resolved = dassourceBrowser.sourceRegistry
1364             .resolveSourceNicknames(sources);
1365     if (resolved.size() == 0)
1366     {
1367       resolved = dassourceBrowser.getSelectedSources();
1368     }
1369     if (resolved.size() > 0)
1370     {
1371       final List<jalviewSourceI> dassources = resolved;
1372       fetchDAS.setEnabled(false);
1373       // cancelDAS.setEnabled(true); doDasFetch does this.
1374       Runnable fetcher = new Runnable()
1375       {
1376
1377         @Override
1378         public void run()
1379         {
1380           doDasFeatureFetch(dassources, true, false);
1381
1382         }
1383       };
1384       if (block)
1385       {
1386         fetcher.run();
1387       }
1388       else
1389       {
1390         SwingUtilities.invokeLater(fetcher);
1391       }
1392     }
1393   }
1394
1395   public void saveDAS_actionPerformed(ActionEvent e)
1396   {
1397     dassourceBrowser
1398             .saveProperties(jalview.bin.Cache.applicationProperties);
1399   }
1400
1401   public void complete()
1402   {
1403     fetchDAS.setEnabled(true);
1404     cancelDAS.setEnabled(false);
1405     dassourceBrowser.setGuiEnabled(true);
1406
1407   }
1408
1409   public void cancelDAS_actionPerformed(ActionEvent e)
1410   {
1411     if (dasFeatureFetcher != null)
1412     {
1413       dasFeatureFetcher.cancel();
1414     }
1415     complete();
1416   }
1417
1418   public void noDasSourceActive()
1419   {
1420     complete();
1421     JvOptionPane
1422             .showInternalConfirmDialog(
1423                     Desktop.desktop,
1424                     MessageManager
1425                             .getString("label.no_das_sources_selected_warn"),
1426                     MessageManager
1427                             .getString("label.no_das_sources_selected_title"),
1428                     JvOptionPane.DEFAULT_OPTION,
1429                     JvOptionPane.INFORMATION_MESSAGE);
1430   }
1431
1432   // ///////////////////////////////////////////////////////////////////////
1433   // http://java.sun.com/docs/books/tutorial/uiswing/components/table.html
1434   // ///////////////////////////////////////////////////////////////////////
1435   class FeatureTableModel extends AbstractTableModel
1436   {
1437     FeatureTableModel(Object[][] data)
1438     {
1439       this.data = data;
1440     }
1441
1442     private String[] columnNames = {
1443         MessageManager.getString("label.feature_type"),
1444         MessageManager.getString("action.colour"),
1445         MessageManager.getString("label.display") };
1446
1447     private Object[][] data;
1448
1449     public Object[][] getData()
1450     {
1451       return data;
1452     }
1453
1454     public void setData(Object[][] data)
1455     {
1456       this.data = data;
1457     }
1458
1459     @Override
1460     public int getColumnCount()
1461     {
1462       return columnNames.length;
1463     }
1464
1465     public Object[] getRow(int row)
1466     {
1467       return data[row];
1468     }
1469
1470     @Override
1471     public int getRowCount()
1472     {
1473       return data.length;
1474     }
1475
1476     @Override
1477     public String getColumnName(int col)
1478     {
1479       return columnNames[col];
1480     }
1481
1482     @Override
1483     public Object getValueAt(int row, int col)
1484     {
1485       return data[row][col];
1486     }
1487
1488     @Override
1489     public Class getColumnClass(int c)
1490     {
1491       return getValueAt(0, c).getClass();
1492     }
1493
1494     @Override
1495     public boolean isCellEditable(int row, int col)
1496     {
1497       return col == 0 ? false : true;
1498     }
1499
1500     @Override
1501     public void setValueAt(Object value, int row, int col)
1502     {
1503       data[row][col] = value;
1504       fireTableCellUpdated(row, col);
1505       updateFeatureRenderer(data);
1506     }
1507
1508   }
1509
1510   class ColorRenderer extends JLabel implements TableCellRenderer
1511   {
1512     javax.swing.border.Border unselectedBorder = null;
1513
1514     javax.swing.border.Border selectedBorder = null;
1515
1516     final String baseTT = "Click to edit, right/apple click for menu.";
1517
1518     public ColorRenderer()
1519     {
1520       setOpaque(true); // MUST do this for background to show up.
1521       setHorizontalTextPosition(SwingConstants.CENTER);
1522       setVerticalTextPosition(SwingConstants.CENTER);
1523     }
1524
1525     @Override
1526     public Component getTableCellRendererComponent(JTable tbl,
1527             Object color, boolean isSelected, boolean hasFocus, int row,
1528             int column)
1529     {
1530       FeatureColourI cellColour = (FeatureColourI) color;
1531       // JLabel comp = new JLabel();
1532       // comp.
1533       setOpaque(true);
1534       // comp.
1535       // setBounds(getBounds());
1536       Color newColor;
1537       setToolTipText(baseTT);
1538       setBackground(tbl.getBackground());
1539       if (!cellColour.isSimpleColour())
1540       {
1541         Rectangle cr = tbl.getCellRect(row, column, false);
1542         FeatureSettings.renderGraduatedColor(this, cellColour,
1543                 (int) cr.getWidth(), (int) cr.getHeight());
1544
1545       }
1546       else
1547       {
1548         this.setText("");
1549         this.setIcon(null);
1550         newColor = cellColour.getColour();
1551         setBackground(newColor);
1552       }
1553       if (isSelected)
1554       {
1555         if (selectedBorder == null)
1556         {
1557           selectedBorder = BorderFactory.createMatteBorder(2, 5, 2, 5,
1558                   tbl.getSelectionBackground());
1559         }
1560         setBorder(selectedBorder);
1561       }
1562       else
1563       {
1564         if (unselectedBorder == null)
1565         {
1566           unselectedBorder = BorderFactory.createMatteBorder(2, 5, 2, 5,
1567                   tbl.getBackground());
1568         }
1569         setBorder(unselectedBorder);
1570       }
1571
1572       return this;
1573     }
1574   }
1575
1576   /**
1577    * update comp using rendering settings from gcol
1578    *
1579    * @param comp
1580    * @param gcol
1581    */
1582   public static void renderGraduatedColor(JLabel comp, FeatureColourI gcol)
1583   {
1584     int w = comp.getWidth(), h = comp.getHeight();
1585     if (w < 20)
1586     {
1587       w = (int) comp.getPreferredSize().getWidth();
1588       h = (int) comp.getPreferredSize().getHeight();
1589       if (w < 20)
1590       {
1591         w = 80;
1592         h = 12;
1593       }
1594     }
1595     renderGraduatedColor(comp, gcol, w, h);
1596   }
1597
1598   public static void renderGraduatedColor(JLabel comp, FeatureColourI gcol,
1599           int w, int h)
1600   {
1601     boolean thr = false;
1602     String tt = "";
1603     String tx = "";
1604     if (gcol.isAboveThreshold())
1605     {
1606       thr = true;
1607       tx += ">";
1608       tt += "Thresholded (Above " + gcol.getThreshold() + ") ";
1609     }
1610     if (gcol.isBelowThreshold())
1611     {
1612       thr = true;
1613       tx += "<";
1614       tt += "Thresholded (Below " + gcol.getThreshold() + ") ";
1615     }
1616     if (gcol.isColourByLabel())
1617     {
1618       tt = "Coloured by label text. " + tt;
1619       if (thr)
1620       {
1621         tx += " ";
1622       }
1623       tx += "Label";
1624       comp.setIcon(null);
1625     }
1626     else
1627     {
1628       Color newColor = gcol.getMaxColour();
1629       comp.setBackground(newColor);
1630       // System.err.println("Width is " + w / 2);
1631       Icon ficon = new FeatureIcon(gcol, comp.getBackground(), w, h, thr);
1632       comp.setIcon(ficon);
1633       // tt+="RGB value: Max (" + newColor.getRed() + ", "
1634       // + newColor.getGreen() + ", " + newColor.getBlue()
1635       // + ")\nMin (" + minCol.getRed() + ", " + minCol.getGreen()
1636       // + ", " + minCol.getBlue() + ")");
1637     }
1638     comp.setHorizontalAlignment(SwingConstants.CENTER);
1639     comp.setText(tx);
1640     if (tt.length() > 0)
1641     {
1642       if (comp.getToolTipText() == null)
1643       {
1644         comp.setToolTipText(tt);
1645       }
1646       else
1647       {
1648         comp.setToolTipText(tt + " " + comp.getToolTipText());
1649       }
1650     }
1651   }
1652 }
1653
1654 class FeatureIcon implements Icon
1655 {
1656   FeatureColourI gcol;
1657
1658   Color backg;
1659
1660   boolean midspace = false;
1661
1662   int width = 50, height = 20;
1663
1664   int s1, e1; // start and end of midpoint band for thresholded symbol
1665
1666   Color mpcolour = Color.white;
1667
1668   FeatureIcon(FeatureColourI gfc, Color bg, int w, int h, boolean mspace)
1669   {
1670     gcol = gfc;
1671     backg = bg;
1672     width = w;
1673     height = h;
1674     midspace = mspace;
1675     if (midspace)
1676     {
1677       s1 = width / 3;
1678       e1 = s1 * 2;
1679     }
1680     else
1681     {
1682       s1 = width / 2;
1683       e1 = s1;
1684     }
1685   }
1686
1687   @Override
1688   public int getIconWidth()
1689   {
1690     return width;
1691   }
1692
1693   @Override
1694   public int getIconHeight()
1695   {
1696     return height;
1697   }
1698
1699   @Override
1700   public void paintIcon(Component c, Graphics g, int x, int y)
1701   {
1702
1703     if (gcol.isColourByLabel())
1704     {
1705       g.setColor(backg);
1706       g.fillRect(0, 0, width, height);
1707       // need an icon here.
1708       g.setColor(gcol.getMaxColour());
1709
1710       g.setFont(new Font("Verdana", Font.PLAIN, 9));
1711
1712       // g.setFont(g.getFont().deriveFont(
1713       // AffineTransform.getScaleInstance(
1714       // width/g.getFontMetrics().stringWidth("Label"),
1715       // height/g.getFontMetrics().getHeight())));
1716
1717       g.drawString(MessageManager.getString("label.label"), 0, 0);
1718
1719     }
1720     else
1721     {
1722       Color minCol = gcol.getMinColour();
1723       g.setColor(minCol);
1724       g.fillRect(0, 0, s1, height);
1725       if (midspace)
1726       {
1727         g.setColor(Color.white);
1728         g.fillRect(s1, 0, e1 - s1, height);
1729       }
1730       g.setColor(gcol.getMaxColour());
1731       g.fillRect(0, e1, width - e1, height);
1732     }
1733   }
1734 }
1735
1736 class ColorEditor extends AbstractCellEditor implements TableCellEditor,
1737         ActionListener
1738 {
1739   FeatureSettings me;
1740
1741   FeatureColourI currentColor;
1742
1743   FeatureColourChooser chooser;
1744
1745   String type;
1746
1747   JButton button;
1748
1749   JColorChooser colorChooser;
1750
1751   JDialog dialog;
1752
1753   protected static final String EDIT = "edit";
1754
1755   int selectedRow = 0;
1756
1757   public ColorEditor(FeatureSettings me)
1758   {
1759     this.me = me;
1760     // Set up the editor (from the table's point of view),
1761     // which is a button.
1762     // This button brings up the color chooser dialog,
1763     // which is the editor from the user's point of view.
1764     button = new JButton();
1765     button.setActionCommand(EDIT);
1766     button.addActionListener(this);
1767     button.setBorderPainted(false);
1768     // Set up the dialog that the button brings up.
1769     colorChooser = new JColorChooser();
1770     dialog = JColorChooser.createDialog(button, "Select new Colour", true, // modal
1771             colorChooser, this, // OK button handler
1772             null); // no CANCEL button handler
1773   }
1774
1775   /**
1776    * Handles events from the editor button and from the dialog's OK button.
1777    */
1778   @Override
1779   public void actionPerformed(ActionEvent e)
1780   {
1781
1782     if (EDIT.equals(e.getActionCommand()))
1783     {
1784       // The user has clicked the cell, so
1785       // bring up the dialog.
1786       if (currentColor.isSimpleColour())
1787       {
1788         // bring up simple color chooser
1789         button.setBackground(currentColor.getColour());
1790         colorChooser.setColor(currentColor.getColour());
1791         dialog.setVisible(true);
1792       }
1793       else
1794       {
1795         // bring up graduated chooser.
1796         chooser = new FeatureColourChooser(me.fr, type);
1797         chooser.setRequestFocusEnabled(true);
1798         chooser.requestFocus();
1799         chooser.addActionListener(this);
1800       }
1801       // Make the renderer reappear.
1802       fireEditingStopped();
1803
1804     }
1805     else
1806     { // User pressed dialog's "OK" button.
1807       if (currentColor.isSimpleColour())
1808       {
1809         currentColor = new FeatureColour(colorChooser.getColor());
1810       }
1811       else
1812       {
1813         currentColor = chooser.getLastColour();
1814       }
1815       me.table.setValueAt(getCellEditorValue(), selectedRow, 1);
1816       fireEditingStopped();
1817       me.table.validate();
1818     }
1819   }
1820
1821   // Implement the one CellEditor method that AbstractCellEditor doesn't.
1822   @Override
1823   public Object getCellEditorValue()
1824   {
1825     return currentColor;
1826   }
1827
1828   // Implement the one method defined by TableCellEditor.
1829   @Override
1830   public Component getTableCellEditorComponent(JTable table, Object value,
1831           boolean isSelected, int row, int column)
1832   {
1833     currentColor = (FeatureColourI) value;
1834     this.selectedRow = row;
1835     type = me.table.getValueAt(row, 0).toString();
1836     button.setOpaque(true);
1837     button.setBackground(me.getBackground());
1838     if (!currentColor.isSimpleColour())
1839     {
1840       JLabel btn = new JLabel();
1841       btn.setSize(button.getSize());
1842       FeatureSettings.renderGraduatedColor(btn, currentColor);
1843       button.setBackground(btn.getBackground());
1844       button.setIcon(btn.getIcon());
1845       button.setText(btn.getText());
1846     }
1847     else
1848     {
1849       button.setText("");
1850       button.setIcon(null);
1851       button.setBackground(currentColor.getColour());
1852     }
1853     return button;
1854   }
1855 }