src/jalview/gui/FeatureSettings.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer
   3  * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18  */
  19 package jalview.gui;
  20
  21 import java.io.*;
  22 import java.util.*;
  23
  24 import java.awt.*;
  25 import java.awt.event.*;
  26 import java.beans.PropertyChangeEvent;
  27 import java.beans.PropertyChangeListener;
  28
  29 import javax.swing.*;
  30 import javax.swing.event.*;
  31 import javax.swing.table.*;
  32
  33 import jalview.datamodel.*;
  34 import jalview.io.*;
  35
  36 public class FeatureSettings
  37     extends JPanel
  38 {
  39   DasSourceBrowser dassourceBrowser;
  40   jalview.io.DasSequenceFeatureFetcher dasFeatureFetcher;
  41   JPanel settingsPane = new JPanel();
  42   JPanel dasSettingsPane = new JPanel();
  43
  44   final FeatureRenderer fr;
  45   public final AlignFrame af;
  46   Object[][] originalData;
  47   final JInternalFrame frame;
  48   JScrollPane scrollPane = new JScrollPane();
  49   JTable table;
  50   JPanel groupPanel;
  51   JSlider transparency = new JSlider();
  52
  53   JPanel transPanel = new JPanel(new FlowLayout());
  54
  55   public FeatureSettings(AlignFrame af)
  56   {
  57     this.af = af;
  58     fr = af.getFeatureRenderer();
  59
  60     transparency.setMaximum(100 - (int) (fr.transparency * 100));
  61
  62     try
  63     {
  64       jbInit();
  65     }
  66     catch (Exception ex)
  67     {
  68       ex.printStackTrace();
  69     }
  70
  71     table = new JTable();
  72     table.getTableHeader().setFont(new Font("Verdana", Font.PLAIN, 12));
  73     table.setFont(new Font("Verdana", Font.PLAIN, 12));
  74     table.setDefaultRenderer(Color.class,
  75                              new ColorRenderer());
  76
  77     table.setDefaultEditor(Color.class,
  78                            new ColorEditor());
  79
  80     table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  81
  82     table.addMouseListener(new MouseAdapter()
  83     {
  84       public void mousePressed(MouseEvent evt)
  85       {
  86         selectedRow = table.rowAtPoint(evt.getPoint());
  87       }
  88     });
  89
  90     table.addMouseMotionListener(new MouseMotionAdapter()
  91     {
  92       public void mouseDragged(MouseEvent evt)
  93       {
  94         int newRow = table.rowAtPoint(evt.getPoint());
  95         if (newRow != selectedRow
  96             && selectedRow != -1
  97             && newRow != -1)
  98         {
  99           Object[] temp = new Object[3];
 100           temp[0] = table.getValueAt(selectedRow, 0);
 101           temp[1] = table.getValueAt(selectedRow, 1);
 102           temp[2] = table.getValueAt(selectedRow, 2);
 103
 104           table.setValueAt(table.getValueAt(newRow, 0), selectedRow, 0);
 105           table.setValueAt(table.getValueAt(newRow, 1), selectedRow, 1);
 106           table.setValueAt(table.getValueAt(newRow, 2), selectedRow, 2);
 107
 108           table.setValueAt(temp[0], newRow, 0);
 109           table.setValueAt(temp[1], newRow, 1);
 110           table.setValueAt(temp[2], newRow, 2);
 111
 112           selectedRow = newRow;
 113         }
 114       }
 115     });
 116
 117     scrollPane.setViewportView(table);
 118
 119     dassourceBrowser = new DasSourceBrowser();
 120     dasSettingsPane.add(dassourceBrowser, BorderLayout.CENTER);
 121
 122     if (af.getViewport().featuresDisplayed == null || fr.renderOrder == null)
 123     {
 124       fr.findAllFeatures(true); // display everything!
 125     }
 126
 127     setTableData();
 128     final PropertyChangeListener change;
 129     final FeatureSettings fs=this;
 130     fr.addPropertyChangeListener(change=new PropertyChangeListener() {
 131       public void propertyChange(PropertyChangeEvent evt)
 132       {
 133         if (!fs.resettingTable && !fs.handlingUpdate) {
 134           fs.handlingUpdate=true;
 135           fs.resetTable(null); // new groups may be added with new seuqence feature types only
 136           fs.handlingUpdate=false;
 137         }
 138       }
 139
 140     });
 141
 142     frame = new JInternalFrame();
 143     frame.setContentPane(this);
 144     Desktop.addInternalFrame(frame, "Sequence Feature Settings", 400, 450);
 145     frame.addInternalFrameListener(new javax.swing.event.InternalFrameAdapter()
 146     {
 147       public void internalFrameClosed(
 148           javax.swing.event.InternalFrameEvent evt)
 149       {
 150         fr.removePropertyChangeListener(change);
 151       }
 152       ;
 153     });
 154     frame.setLayer(JLayeredPane.PALETTE_LAYER);
 155   }
 156   /**
 157    * true when Feature Settings are updating from feature renderer
 158    */
 159   private boolean handlingUpdate=false;
 160
 161   /**
 162    * contains a float[3] for each feature type string. created by setTableData
 163    */
 164   Hashtable typeWidth=null;
 165   synchronized public void setTableData()
 166   {
 167     if (fr.featureGroups == null)
 168     {
 169       fr.featureGroups = new Hashtable();
 170     }
 171     Vector allFeatures = new Vector();
 172     Vector allGroups = new Vector();
 173     SequenceFeature[] tmpfeatures;
 174     String group;
 175     for (int i = 0; i < af.getViewport().alignment.getHeight(); i++)
 176     {
 177       if (af.getViewport().alignment.getSequenceAt(i).getDatasetSequence().
 178           getSequenceFeatures() == null)
 179       {
 180         continue;
 181       }
 182
 183       tmpfeatures = af.getViewport().alignment.getSequenceAt(i).
 184           getDatasetSequence().getSequenceFeatures();
 185
 186       int index = 0;
 187       while (index < tmpfeatures.length)
 188       {
 189         if (tmpfeatures[index].begin == 0 && tmpfeatures[index].end == 0)
 190         {
 191           index++;
 192           continue;
 193         }
 194
 195         if (tmpfeatures[index].getFeatureGroup() != null)
 196         {
 197           group = tmpfeatures[index].featureGroup;
 198           if (!allGroups.contains(group))
 199           {
 200             allGroups.addElement(group);
 201             if (group!=null)
 202             {
 203               checkGroupState(group);
 204             }
 205           }
 206         }
 207
 208         if (!allFeatures.contains(tmpfeatures[index].getType()))
 209         {
 210           allFeatures.addElement(tmpfeatures[index].getType());
 211         }
 212         index++;
 213       }
 214     }
 215
 216     resetTable(null);
 217
 218     validate();
 219   }
 220   /**
 221    *
 222    * @param group
 223    * @return true if group has been seen before and is already added to set.
 224    */
 225   private boolean checkGroupState(String group) {
 226     boolean visible;
 227     if (fr.featureGroups.containsKey(group))
 228     {
 229       visible = ( (Boolean) fr.featureGroups.get(group)).booleanValue();
 230         } else {
 231         visible=true; // new group is always made visible
 232       }
 233
 234       if (groupPanel == null)
 235       {
 236         groupPanel = new JPanel();
 237       }
 238
 239       boolean alreadyAdded = false;
 240       for (int g = 0; g < groupPanel.getComponentCount(); g++)
 241       {
 242         if ( ( (JCheckBox) groupPanel.getComponent(g))
 243             .getText().equals(group))
 244         {
 245           alreadyAdded = true;
 246           ((JCheckBox)groupPanel.getComponent(g)).setSelected(visible);
 247           break;
 248         }
 249       }
 250
 251       if (alreadyAdded)
 252       {
 253
 254         return true;
 255       }
 256
 257       fr.featureGroups.put(group, new Boolean(visible));
 258       final String grp = group;
 259       final JCheckBox check = new JCheckBox(group, visible);
 260       check.setFont(new Font("Serif", Font.BOLD, 12));
 261       check.addItemListener(new ItemListener()
 262       {
 263         public void itemStateChanged(ItemEvent evt)
 264         {
 265           fr.featureGroups.put(check.getText(),
 266                                new Boolean(check.isSelected()));
 267           af.alignPanel.seqPanel.seqCanvas.repaint();
 268           if (af.alignPanel.overviewPanel != null)
 269           {
 270             af.alignPanel.overviewPanel.updateOverviewImage();
 271           }
 272
 273           resetTable(new String[] { grp } );
 274         }
 275       });
 276       groupPanel.add(check);
 277       return false;
 278   }
 279   boolean resettingTable=false;
 280   void resetTable(String[] groupChanged)
 281   {
 282     resettingTable=true;
 283     typeWidth=new Hashtable();
 284     // TODO: change avWidth calculation to 'per-sequence' average and use long rather than float
 285     float[] avWidth=null;
 286     SequenceFeature[] tmpfeatures;
 287     String group = null, type;
 288     Vector visibleChecks = new Vector();
 289
 290     //Find out which features should be visible depending on which groups
 291     //are selected / deselected
 292     //and recompute average width ordering
 293     for (int i = 0; i < af.getViewport().alignment.getHeight(); i++)
 294     {
 295
 296       tmpfeatures = af.getViewport().alignment.getSequenceAt(i).
 297           getDatasetSequence().getSequenceFeatures();
 298       if (tmpfeatures == null)
 299       {
 300         continue;
 301       }
 302
 303       int index = 0;
 304       while (index < tmpfeatures.length)
 305       {
 306         group = tmpfeatures[index].featureGroup;
 307
 308         if (tmpfeatures[index].begin == 0 && tmpfeatures[index].end == 0)
 309         {
 310           index++;
 311           continue;
 312         }
 313
 314         if (group == null || fr.featureGroups.get(group) == null ||
 315             ( (Boolean) fr.featureGroups.get(group)).booleanValue())
 316         {
 317           if (group!=null)
 318             checkGroupState(group);
 319           type = tmpfeatures[index].getType();
 320           if (!visibleChecks.contains(type))
 321           {
 322             visibleChecks.addElement(type);
 323           }
 324         }
 325         if (!typeWidth.containsKey(tmpfeatures[index].getType())) {
 326           typeWidth.put(tmpfeatures[index].getType(), avWidth=new float[3]);
 327         } else {
 328           avWidth = (float[]) typeWidth.get(tmpfeatures[index].getType());
 329         }
 330         avWidth[0]++;
 331         if (tmpfeatures[index].getBegin()>tmpfeatures[index].getEnd())
 332         {
 333           avWidth[1]+=1+tmpfeatures[index].getBegin()-tmpfeatures[index].getEnd();
 334         } else {
 335           avWidth[1]+=1+tmpfeatures[index].getEnd()-tmpfeatures[index].getBegin();
 336         }
 337         index++;
 338       }
 339     }
 340
 341     int fSize = visibleChecks.size();
 342     Object[][] data = new Object[fSize][3];
 343     int dataIndex = 0;
 344
 345     if (fr.renderOrder != null)
 346     {
 347       if (!handlingUpdate)
 348         fr.findAllFeatures(groupChanged!=null); // prod to update colourschemes. but don't affect display
 349       //First add the checks in the previous render order,
 350       //in case the window has been closed and reopened
 351       for (int ro = fr.renderOrder.length - 1; ro > -1; ro--)
 352       {
 353         type = fr.renderOrder[ro];
 354
 355         if (!visibleChecks.contains(type))
 356         {
 357           continue;
 358         }
 359
 360         data[dataIndex][0] = type;
 361         data[dataIndex][1] = fr.getColour(type);
 362         data[dataIndex][2] = new Boolean(af.getViewport().featuresDisplayed.containsKey(type));
 363         dataIndex++;
 364         visibleChecks.removeElement(type);
 365       }
 366     }
 367
 368     fSize = visibleChecks.size();
 369     for (int i = 0; i < fSize; i++)
 370     {
 371       //These must be extra features belonging to the group
 372       //which was just selected
 373       type = visibleChecks.elementAt(i).toString();
 374       data[dataIndex][0] = type;
 375
 376       data[dataIndex][1] = fr.getColour(type);
 377       if (data[dataIndex][1] == null)
 378       {
 379         //"Colour has been updated in another view!!"
 380         fr.renderOrder = null;
 381         return;
 382       }
 383
 384       data[dataIndex][2] = new Boolean(true);
 385       dataIndex++;
 386     }
 387
 388     if (originalData == null)
 389     {
 390       originalData = new Object[data.length][3];
 391       System.arraycopy(data, 0, originalData, 0, data.length);
 392     }
 393
 394     table.setModel(new FeatureTableModel(data));
 395     table.getColumnModel().getColumn(0).setPreferredWidth(200);
 396
 397     if (groupPanel != null)
 398     {
 399       groupPanel.setLayout(
 400           new GridLayout(fr.featureGroups.size() / 4 + 1, 4));
 401
 402       groupPanel.validate();
 403       bigPanel.add(groupPanel, BorderLayout.NORTH);
 404     }
 405
 406     updateFeatureRenderer(data, groupChanged!=null);
 407     resettingTable=false;
 408   }
 409   /**
 410    * reorder data based on the featureRenderers global priority list.
 411    * @param data
 412    */
 413   private void ensureOrder(Object[][] data)
 414   {
 415     boolean sort=false;
 416     float[] order = new float[data.length];
 417     for (int i=0;i<order.length; i++)
 418     {
 419       order[i] = fr.getOrder(data[i][0].toString());
 420       if (order[i]<0)
 421         order[i] = fr.setOrder(data[i][0].toString(), i/order.length);
 422       if (i>1)
 423         sort = sort || order[i-1]>order[i];
 424     }
 425     if (sort)
 426       jalview.util.QuickSort.sort(order, data);
 427   }
 428
 429   void load()
 430   {
 431     JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache.
 432         getProperty(
 433             "LAST_DIRECTORY"), new String[]
 434         {"fc"},
 435         new String[]
 436         {"Sequence Feature Colours"}, "Sequence Feature Colours");
 437     chooser.setFileView(new jalview.io.JalviewFileView());
 438     chooser.setDialogTitle("Load Feature Colours");
 439     chooser.setToolTipText("Load");
 440
 441     int value = chooser.showOpenDialog(this);
 442
 443     if (value == JalviewFileChooser.APPROVE_OPTION)
 444     {
 445       File file = chooser.getSelectedFile();
 446
 447       try
 448       {
 449         InputStreamReader in = new InputStreamReader(new FileInputStream(
 450             file), "UTF-8");
 451
 452         jalview.binding.JalviewUserColours jucs = new jalview.binding.
 453             JalviewUserColours();
 454         jucs = (jalview.binding.JalviewUserColours) jucs.unmarshal(in);
 455
 456         for (int i = jucs.getColourCount()-1; i >=0; i--)
 457         {
 458           String name;
 459           fr.setColour(name=jucs.getColour(i).getName(),
 460                        new Color(Integer.parseInt(jucs.getColour(i).getRGB(),
 461                                                   16)));
 462           fr.setOrder(name,(i==0) ? 0 : i/jucs.getColourCount());
 463         }
 464         if (table!=null) {
 465           resetTable(null);
 466           Object[][] data=((FeatureTableModel) table.getModel()).getData();
 467           ensureOrder(data);
 468           updateFeatureRenderer(data,false);
 469           table.repaint();
 470         }
 471       }
 472       catch (Exception ex)
 473       {
 474         System.out.println("Error loading User Colour File\n" + ex);
 475       }
 476     }
 477   }
 478
 479   void save()
 480   {
 481     JalviewFileChooser chooser = new JalviewFileChooser(jalview.bin.Cache.
 482         getProperty(
 483             "LAST_DIRECTORY"), new String[]
 484         {"fc"},
 485         new String[]
 486         {"Sequence Feature Colours"}, "Sequence Feature Colours");
 487     chooser.setFileView(new jalview.io.JalviewFileView());
 488     chooser.setDialogTitle("Save Feature Colour Scheme");
 489     chooser.setToolTipText("Save");
 490
 491     int value = chooser.showSaveDialog(this);
 492
 493     if (value == JalviewFileChooser.APPROVE_OPTION)
 494     {
 495       String choice = chooser.getSelectedFile().getPath();
 496       jalview.binding.JalviewUserColours ucs = new jalview.binding.
 497           JalviewUserColours();
 498       ucs.setSchemeName("Sequence Features");
 499       try
 500       {
 501         PrintWriter out = new PrintWriter(new OutputStreamWriter(
 502             new FileOutputStream(choice), "UTF-8"));
 503
 504         Enumeration e = fr.featureColours.keys();
 505         float[] sortOrder = new float[fr.featureColours.size()];
 506         String[] sortTypes = new String[fr.featureColours.size()];
 507         int i=0;
 508         while (e.hasMoreElements())
 509         {
 510           sortTypes[i] = e.nextElement().toString();
 511           sortOrder[i]  = fr.getOrder(sortTypes[i]);
 512           i++;
 513         }
 514         jalview.util.QuickSort.sort(sortOrder, sortTypes);
 515         sortOrder=null;
 516         for (i=0; i<sortTypes.length; i++) {
 517           jalview.binding.Colour col = new jalview.binding.Colour();
 518           col.setName(sortTypes[i]);
 519           col.setRGB(jalview.util.Format.getHexString(
 520               fr.getColour(col.getName())));
 521           ucs.addColour(col);
 522         }
 523         ucs.marshal(out);
 524         out.close();
 525       }
 526       catch (Exception ex)
 527       {
 528         ex.printStackTrace();
 529       }
 530     }
 531   }
 532
 533   public void invertSelection()
 534   {
 535     for (int i = 0; i < table.getRowCount(); i++)
 536     {
 537       Boolean value = (Boolean) table.getValueAt(i, 2);
 538
 539       table.setValueAt(
 540           new Boolean(!value.booleanValue()),
 541           i, 2);
 542     }
 543   }
 544   public void orderByAvWidth() {
 545     if (table==null || table.getModel()==null)
 546       return;
 547     Object[][] data = ((FeatureTableModel) table.getModel()).getData();
 548     float[] width = new float[data.length];
 549     float[] awidth;
 550     float max=0;
 551     int num=0;
 552     for (int i=0;i<data.length;i++) {
 553        awidth = (float[]) typeWidth.get(data[i][0]);
 554        if (awidth[0]>0) {
 555          width[i] = awidth[1]/awidth[0];// *awidth[0]*awidth[2]; - better weight - but have to make per sequence, too (awidth[2])
 556          //if (width[i]==1) // hack to distinguish single width sequences.
 557          num++;
 558        } else {
 559          width[i]=0;
 560        }
 561        if (max<width[i])
 562          max=width[i];
 563     }
 564     boolean sort=false;
 565     for (int i=0;i<width.length; i++) {
 566       //awidth = (float[]) typeWidth.get(data[i][0]);
 567       if (width[i]==0)
 568       {
 569         width[i] = fr.getOrder(data[i][0].toString());
 570         if (width[i]<0)
 571         {
 572           width[i] = fr.setOrder(data[i][0].toString(), i/data.length);
 573         }
 574       } else {
 575         width[i] /=max; // normalize
 576         fr.setOrder(data[i][0].toString(), width[i]); // store for later
 577       }
 578       if (i>0)
 579         sort = sort || width[i-1]>width[i];
 580     }
 581     if (sort)
 582       jalview.util.QuickSort.sort(width, data);
 583     // update global priority order
 584
 585     updateFeatureRenderer(data,false);
 586     table.repaint();
 587   }
 588   public void close()
 589   {
 590     try
 591     {
 592       frame.setClosed(true);
 593     }
 594     catch (Exception exe)
 595     {}
 596
 597   }
 598
 599   public void updateFeatureRenderer(Object[][] data)
 600   {
 601     updateFeatureRenderer(data, true);
 602   }
 603   private void updateFeatureRenderer(Object[][] data, boolean visibleNew)
 604   {
 605     fr.setFeaturePriority(data, visibleNew);
 606     af.alignPanel.paintAlignment(true);
 607   }
 608
 609   int selectedRow = -1;
 610   JTabbedPane tabbedPane = new JTabbedPane();
 611   BorderLayout borderLayout1 = new BorderLayout();
 612   BorderLayout borderLayout2 = new BorderLayout();
 613   BorderLayout borderLayout3 = new BorderLayout();
 614   JPanel bigPanel = new JPanel();
 615   BorderLayout borderLayout4 = new BorderLayout();
 616   JButton invert = new JButton();
 617   JPanel buttonPanel = new JPanel();
 618   JButton cancel = new JButton();
 619   JButton ok = new JButton();
 620   JButton loadColours = new JButton();
 621   JButton saveColours = new JButton();
 622   JPanel dasButtonPanel = new JPanel();
 623   JButton fetchDAS = new JButton();
 624   JButton saveDAS = new JButton();
 625   JButton cancelDAS = new JButton();
 626   JButton optimizeOrder = new JButton();
 627   JPanel transbuttons = new JPanel(new BorderLayout());
 628   private void jbInit()
 629       throws Exception
 630   {
 631     this.setLayout(borderLayout1);
 632     settingsPane.setLayout(borderLayout2);
 633     dasSettingsPane.setLayout(borderLayout3);
 634     bigPanel.setLayout(borderLayout4);
 635     invert.setFont(new java.awt.Font("Verdana", Font.PLAIN, 11));
 636     invert.setText("Invert Selection");
 637     invert.addActionListener(new ActionListener()
 638     {
 639       public void actionPerformed(ActionEvent e)
 640       {
 641         invertSelection();
 642       }
 643     });
 644     optimizeOrder.setFont(new java.awt.Font("Verdana", Font.PLAIN, 11));
 645     optimizeOrder.setText("Optimise Order");
 646     optimizeOrder.addActionListener(new ActionListener() {
 647       public void actionPerformed(ActionEvent e) {
 648         orderByAvWidth();
 649       }
 650     });
 651     cancel.setFont(new java.awt.Font("Verdana", Font.PLAIN, 11));
 652     cancel.setText("Cancel");
 653     cancel.addActionListener(new ActionListener()
 654     {
 655       public void actionPerformed(ActionEvent e)
 656       {
 657         updateFeatureRenderer(originalData);
 658         close();
 659       }
 660     });
 661     ok.setFont(new java.awt.Font("Verdana", Font.PLAIN, 11));
 662     ok.setText("OK");
 663     ok.addActionListener(new ActionListener()
 664     {
 665       public void actionPerformed(ActionEvent e)
 666       {
 667         close();
 668       }
 669     });
 670     loadColours.setFont(new java.awt.Font("Verdana", Font.PLAIN, 11));
 671     loadColours.setText("Load Colours");
 672     loadColours.addActionListener(new ActionListener()
 673     {
 674       public void actionPerformed(ActionEvent e)
 675       {
 676         load();
 677       }
 678     });
 679     saveColours.setFont(new java.awt.Font("Verdana", Font.PLAIN, 11));
 680     saveColours.setText("Save Colours");
 681     saveColours.addActionListener(new ActionListener()
 682     {
 683       public void actionPerformed(ActionEvent e)
 684       {
 685         save();
 686       }
 687     });
 688     transparency.addChangeListener(new ChangeListener()
 689     {
 690       public void stateChanged(ChangeEvent evt)
 691       {
 692         fr.setTransparency( (float) (100 - transparency.getValue()) / 100f);
 693         af.alignPanel.paintAlignment(true);
 694       }
 695     });
 696
 697     transparency.setMaximum(70);
 698     fetchDAS.setText("Fetch DAS Features");
 699     fetchDAS.addActionListener(new ActionListener()
 700     {
 701       public void actionPerformed(ActionEvent e)
 702       {
 703         fetchDAS_actionPerformed(e);
 704       }
 705     });
 706     saveDAS.setText("Save as default");
 707     saveDAS.addActionListener(new ActionListener()
 708     {
 709       public void actionPerformed(ActionEvent e)
 710       {
 711         saveDAS_actionPerformed(e);
 712       }
 713     });
 714     dasButtonPanel.setBorder(BorderFactory.createEtchedBorder());
 715     dasSettingsPane.setBorder(null);
 716     cancelDAS.setEnabled(false);
 717     cancelDAS.setText("Cancel Fetch");
 718     cancelDAS.addActionListener(new ActionListener()
 719     {
 720       public void actionPerformed(ActionEvent e)
 721       {
 722         cancelDAS_actionPerformed(e);
 723       }
 724     });
 725     this.add(tabbedPane, java.awt.BorderLayout.CENTER);
 726     tabbedPane.addTab("Feature Settings", settingsPane);
 727     tabbedPane.addTab("DAS Settings", dasSettingsPane);
 728     bigPanel.add(transPanel, java.awt.BorderLayout.SOUTH);
 729     transPanel.add(transparency);
 730     transbuttons.add(invert, java.awt.BorderLayout.NORTH);
 731     transbuttons.add(optimizeOrder,java.awt.BorderLayout.SOUTH);
 732     transPanel.add(transbuttons);
 733     buttonPanel.add(ok);
 734     buttonPanel.add(cancel);
 735     buttonPanel.add(loadColours);
 736     buttonPanel.add(saveColours);
 737     bigPanel.add(scrollPane, java.awt.BorderLayout.CENTER);
 738     dasSettingsPane.add(dasButtonPanel, java.awt.BorderLayout.SOUTH);
 739     dasButtonPanel.add(fetchDAS);
 740     dasButtonPanel.add(cancelDAS);
 741     dasButtonPanel.add(saveDAS);
 742     settingsPane.add(bigPanel, java.awt.BorderLayout.CENTER);
 743     settingsPane.add(buttonPanel, java.awt.BorderLayout.SOUTH);
 744   }
 745
 746   public void fetchDAS_actionPerformed(ActionEvent e)
 747   {
 748     fetchDAS.setEnabled(false);
 749     cancelDAS.setEnabled(true);
 750     Vector selectedSources = dassourceBrowser.getSelectedSources();
 751
 752     SequenceI[] dataset, seqs;
 753     int iSize;
 754
 755     if (af.getViewport().getSelectionGroup() != null
 756         && af.getViewport().getSelectionGroup().getSize() > 0)
 757     {
 758       iSize = af.getViewport().getSelectionGroup().getSize();
 759       dataset = new SequenceI[iSize];
 760       seqs = af.getViewport().getSelectionGroup().
 761           getSequencesInOrder(
 762               af.getViewport().getAlignment());
 763     }
 764     else
 765     {
 766       iSize = af.getViewport().getAlignment().getHeight();
 767       seqs = af.getViewport().getAlignment().getSequencesArray();
 768     }
 769
 770     dataset = new SequenceI[iSize];
 771     for (int i = 0; i < iSize; i++)
 772     {
 773       dataset[i] = seqs[i].getDatasetSequence();
 774     }
 775
 776     dasFeatureFetcher =
 777         new jalview.io.DasSequenceFeatureFetcher(
 778             dataset,
 779             this,
 780             selectedSources);
 781     cancelDAS.setEnabled(true);
 782     af.getViewport().setShowSequenceFeatures(true);
 783     af.showSeqFeatures.setSelected(true);
 784   }
 785
 786   public void saveDAS_actionPerformed(ActionEvent e)
 787   {
 788     dassourceBrowser.saveProperties(jalview.bin.Cache.applicationProperties);
 789   }
 790
 791   public void complete()
 792   {
 793     fetchDAS.setEnabled(true);
 794     cancelDAS.setEnabled(false);
 795   }
 796
 797   public void cancelDAS_actionPerformed(ActionEvent e)
 798   {
 799     dasFeatureFetcher.cancel();
 800     fetchDAS.setEnabled(true);
 801     cancelDAS.setEnabled(false);
 802   }
 803
 804   /////////////////////////////////////////////////////////////////////////
 805   // http://java.sun.com/docs/books/tutorial/uiswing/components/table.html
 806   /////////////////////////////////////////////////////////////////////////
 807   class FeatureTableModel
 808       extends AbstractTableModel
 809   {
 810     FeatureTableModel(Object[][] data)
 811     {
 812       this.data = data;
 813     }
 814
 815     private String[] columnNames =
 816         {
 817         "Feature Type", "Colour", "Display"};
 818     private Object[][] data;
 819
 820     public Object[][] getData()
 821     {
 822       return data;
 823     }
 824
 825     public void setData(Object[][] data)
 826     {
 827       this.data = data;
 828     }
 829
 830     public int getColumnCount()
 831     {
 832       return columnNames.length;
 833     }
 834
 835     public Object[] getRow(int row)
 836     {
 837       return data[row];
 838     }
 839
 840     public int getRowCount()
 841     {
 842       return data.length;
 843     }
 844
 845     public String getColumnName(int col)
 846     {
 847       return columnNames[col];
 848     }
 849
 850     public Object getValueAt(int row, int col)
 851     {
 852       return data[row][col];
 853     }
 854
 855     public Class getColumnClass(int c)
 856     {
 857       return getValueAt(0, c).getClass();
 858     }
 859
 860     public boolean isCellEditable(int row, int col)
 861     {
 862       return col == 0 ? false : true;
 863     }
 864
 865     public void setValueAt(Object value, int row, int col)
 866     {
 867       data[row][col] = value;
 868       fireTableCellUpdated(row, col);
 869       updateFeatureRenderer(data);
 870     }
 871
 872   }
 873
 874   class ColorRenderer
 875       extends JLabel implements TableCellRenderer
 876   {
 877     javax.swing.border.Border unselectedBorder = null;
 878     javax.swing.border.Border selectedBorder = null;
 879
 880     public ColorRenderer()
 881     {
 882       setOpaque(true); //MUST do this for background to show up.
 883     }
 884
 885     public Component getTableCellRendererComponent(
 886         JTable table, Object color,
 887         boolean isSelected, boolean hasFocus,
 888         int row, int column)
 889     {
 890       Color newColor = (Color) color;
 891       setBackground(newColor);
 892       if (isSelected)
 893       {
 894         if (selectedBorder == null)
 895         {
 896           selectedBorder = BorderFactory.createMatteBorder(2, 5, 2, 5,
 897               table.getSelectionBackground());
 898         }
 899         setBorder(selectedBorder);
 900       }
 901       else
 902       {
 903         if (unselectedBorder == null)
 904         {
 905           unselectedBorder = BorderFactory.createMatteBorder(2, 5, 2, 5,
 906               table.getBackground());
 907         }
 908         setBorder(unselectedBorder);
 909       }
 910
 911       setToolTipText("RGB value: " + newColor.getRed() + ", "
 912                      + newColor.getGreen() + ", "
 913                      + newColor.getBlue());
 914       return this;
 915     }
 916   }
 917 }
 918
 919 class ColorEditor
 920     extends AbstractCellEditor implements TableCellEditor,
 921     ActionListener
 922 {
 923   Color currentColor;
 924   JButton button;
 925   JColorChooser colorChooser;
 926   JDialog dialog;
 927   protected static final String EDIT = "edit";
 928
 929   public ColorEditor()
 930   {
 931     //Set up the editor (from the table's point of view),
 932     //which is a button.
 933     //This button brings up the color chooser dialog,
 934     //which is the editor from the user's point of view.
 935     button = new JButton();
 936     button.setActionCommand(EDIT);
 937     button.addActionListener(this);
 938     button.setBorderPainted(false);
 939     //Set up the dialog that the button brings up.
 940     colorChooser = new JColorChooser();
 941     dialog = JColorChooser.createDialog(button,
 942                                         "Select new Colour",
 943                                         true, //modal
 944                                         colorChooser,
 945                                         this, //OK button handler
 946                                         null); //no CANCEL button handler
 947   }
 948
 949   /**
 950    * Handles events from the editor button and from
 951    * the dialog's OK button.
 952    */
 953   public void actionPerformed(ActionEvent e)
 954   {
 955
 956     if (EDIT.equals(e.getActionCommand()))
 957     {
 958       //The user has clicked the cell, so
 959       //bring up the dialog.
 960       button.setBackground(currentColor);
 961       colorChooser.setColor(currentColor);
 962       dialog.setVisible(true);
 963
 964       //Make the renderer reappear.
 965       fireEditingStopped();
 966
 967     }
 968     else
 969     { //User pressed dialog's "OK" button.
 970       currentColor = colorChooser.getColor();
 971     }
 972   }
 973
 974   //Implement the one CellEditor method that AbstractCellEditor doesn't.
 975   public Object getCellEditorValue()
 976   {
 977     return currentColor;
 978   }
 979
 980   //Implement the one method defined by TableCellEditor.
 981   public Component getTableCellEditorComponent(JTable table,
 982                                                Object value,
 983                                                boolean isSelected,
 984                                                int row,
 985                                                int column)
 986   {
 987     currentColor = (Color) value;
 988     return button;
 989   }
 990 }