src/jalview/appletgui/FeatureSettings.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
   3  * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
   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 of the License, or (at your option) any later version.
  10  *
  11  * Jalview is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty
  13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14  * PURPOSE.  See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 package jalview.appletgui;
  19
  20 import java.util.*;
  21
  22 import java.awt.*;
  23 import java.awt.event.*;
  24
  25 import jalview.analysis.AlignmentSorter;
  26 import jalview.commands.OrderCommand;
  27 import jalview.datamodel.*;
  28 import jalview.schemes.AnnotationColourGradient;
  29 import jalview.schemes.GraduatedColor;
  30
  31 public class FeatureSettings extends Panel implements ItemListener,
  32         MouseListener, MouseMotionListener, ActionListener,
  33         AdjustmentListener
  34 {
  35   FeatureRenderer fr;
  36
  37   AlignmentPanel ap;
  38
  39   AlignViewport av;
  40
  41   Frame frame;
  42
  43   Panel groupPanel;
  44
  45   Panel featurePanel = new Panel();
  46
  47   ScrollPane scrollPane;
  48
  49   boolean alignmentHasFeatures = false;
  50
  51   Image linkImage;
  52
  53   Scrollbar transparency;
  54
  55   public FeatureSettings(final AlignmentPanel ap)
  56   {
  57     this.ap = ap;
  58     this.av = ap.av;
  59     ap.av.featureSettings = this;
  60     fr = ap.seqPanel.seqCanvas.getFeatureRenderer();
  61
  62     transparency = new Scrollbar(Scrollbar.HORIZONTAL,
  63             100 - (int) (fr.transparency * 100), 1, 1, 100);
  64
  65     if (fr.transparencySetter != null)
  66     {
  67       transparency.addAdjustmentListener(this);
  68     }
  69     else
  70     {
  71       transparency.setEnabled(false);
  72     }
  73
  74     java.net.URL url = getClass().getResource("/images/link.gif");
  75     if (url != null)
  76     {
  77       linkImage = java.awt.Toolkit.getDefaultToolkit().getImage(url);
  78     }
  79
  80     if (av.featuresDisplayed == null)
  81     {
  82       fr.findAllFeatures();
  83     }
  84
  85     setTableData();
  86
  87     this.setLayout(new BorderLayout());
  88     scrollPane = new ScrollPane();
  89     scrollPane.add(featurePanel);
  90     if (alignmentHasFeatures)
  91     {
  92       add(scrollPane, BorderLayout.CENTER);
  93     }
  94
  95     Button invert = new Button("Invert Selection");
  96     invert.addActionListener(this);
  97
  98     Panel lowerPanel = new Panel(new GridLayout(2, 1, 5, 10));
  99     lowerPanel.add(invert);
 100
 101     Panel tPanel = new Panel(new BorderLayout());
 102
 103     if (fr.transparencySetter != null)
 104     {
 105       tPanel.add(transparency, BorderLayout.CENTER);
 106       tPanel.add(new Label("Transparency"), BorderLayout.EAST);
 107     }
 108     else
 109     {
 110       tPanel.add(
 111               new Label("Transparency not available in this web browser"),
 112               BorderLayout.CENTER);
 113     }
 114
 115     lowerPanel.add(tPanel, BorderLayout.SOUTH);
 116
 117     add(lowerPanel, BorderLayout.SOUTH);
 118
 119     if (groupPanel != null)
 120     {
 121       groupPanel
 122               .setLayout(new GridLayout(
 123                       (fr.featureGroups.size() - fr.hiddenGroups.size()) / 4 + 1,
 124                       4));
 125       groupPanel.validate();
 126
 127       add(groupPanel, BorderLayout.NORTH);
 128     }
 129     frame = new Frame();
 130     frame.add(this);
 131     final FeatureSettings me = this;
 132     frame.addWindowListener(new WindowAdapter()
 133     {
 134       public void windowClosing(WindowEvent e)
 135       {
 136         if (me.av.featureSettings == me)
 137         {
 138           me.av.featureSettings = null;
 139           me.ap = null;
 140           me.av = null;
 141         }
 142       }
 143     });
 144     int height = featurePanel.getComponentCount() * 50 + 60;
 145
 146     height = Math.max(200, height);
 147     height = Math.min(400, height);
 148     int width = 300;
 149     jalview.bin.JalviewLite.addFrame(frame, "Feature Settings", width,
 150             height);
 151   }
 152
 153   public void paint(Graphics g)
 154   {
 155     g.setColor(Color.black);
 156     g.drawString("No Features added to this alignment!!", 10, 20);
 157     g.drawString("(Features can be added from searches or", 10, 40);
 158     g.drawString("from Jalview / GFF features files)", 10, 60);
 159   }
 160
 161   protected void popupSort(final MyCheckbox check, final Hashtable minmax,
 162           int x, int y)
 163   {
 164     final String type = check.type;
 165     final Object typeCol = fr.getFeatureStyle(type);
 166     java.awt.PopupMenu men = new PopupMenu("Settings for " + type);
 167     java.awt.MenuItem scr = new MenuItem("Sort by Score");
 168     men.add(scr);
 169     final FeatureSettings me = this;
 170     scr.addActionListener(new ActionListener()
 171     {
 172
 173       public void actionPerformed(ActionEvent e)
 174       {
 175         me.sortByScore(new String[]
 176         { type });
 177       }
 178
 179     });
 180     MenuItem dens = new MenuItem("Sort by Density");
 181     dens.addActionListener(new ActionListener()
 182     {
 183
 184       public void actionPerformed(ActionEvent e)
 185       {
 186         me.sortByDens(new String[]
 187         { type });
 188       }
 189
 190     });
 191     men.add(dens);
 192     if (minmax != null)
 193     {
 194       final Object typeMinMax = minmax.get(type);
 195       /*
 196        * final java.awt.CheckboxMenuItem chb = new
 197        * java.awt.CheckboxMenuItem("Vary Height"); // this is broken at the
 198        * moment chb.setState(minmax.get(type) != null);
 199        * chb.addActionListener(new ActionListener() {
 200        *
 201        * public void actionPerformed(ActionEvent e) {
 202        * chb.setState(chb.getState()); if (chb.getState()) { minmax.put(type,
 203        * null); } else { minmax.put(type, typeMinMax); } }
 204        *
 205        * }); men.add(chb);
 206        */
 207       if (typeMinMax != null && ((float[][]) typeMinMax)[0] != null)
 208       {
 209         // graduated colourschemes for those where minmax exists for the
 210         // positional features
 211         MenuItem mxcol = new MenuItem(
 212                 (typeCol instanceof Color) ? "Graduated Colour"
 213                         : "Single Colour");
 214         men.add(mxcol);
 215         mxcol.addActionListener(new ActionListener()
 216         {
 217
 218           public void actionPerformed(ActionEvent e)
 219           {
 220             if (typeCol instanceof Color)
 221             {
 222               new FeatureColourChooser(me, type);
 223               // write back the current colour object to update the table
 224               check.updateColor(fr.getFeatureStyle(type));
 225             }
 226             else
 227             {
 228               new UserDefinedColours(me, check.type,
 229                       ((GraduatedColor) typeCol));
 230             }
 231           }
 232
 233         });
 234       }
 235     }
 236     this.featurePanel.add(men);
 237     men.show(this.featurePanel, x, y);
 238   }
 239
 240   public void setTableData()
 241   {
 242     alignmentHasFeatures = fr.buildGroupHash();
 243     if (alignmentHasFeatures)
 244     {
 245       rebuildGroups();
 246
 247     }
 248     resetTable(false);
 249   }
 250
 251   /**
 252    * rebuilds the group panel
 253    */
 254   public void rebuildGroups()
 255   {
 256     boolean rdrw = false;
 257     if (groupPanel == null)
 258     {
 259       groupPanel = new Panel();
 260     }
 261     else
 262     {
 263       rdrw = true;
 264       groupPanel.removeAll();
 265     }
 266     // TODO: JAL-964 - smoothly incorporate new group entries if panel already
 267     // displayed and new groups present
 268     Enumeration gps = fr.featureGroups.keys();
 269     while (gps.hasMoreElements())
 270     {
 271       String group = (String) gps.nextElement();
 272       Boolean vis = (Boolean) fr.featureGroups.get(group);
 273       Checkbox check = new MyCheckbox(group, vis.booleanValue(),
 274               (fr.featureLinks != null && fr.featureLinks
 275                       .containsKey(group)));
 276       check.addMouseListener(this);
 277       check.setFont(new Font("Serif", Font.BOLD, 12));
 278       check.addItemListener(this);
 279       check.setVisible(fr.hiddenGroups.contains(group));
 280       groupPanel.add(check);
 281     }
 282     if (rdrw)
 283     {
 284       groupPanel.validate();
 285     }
 286   }
 287
 288   // This routine adds and removes checkboxes depending on
 289   // Group selection states
 290   void resetTable(boolean groupsChanged)
 291   {
 292     SequenceFeature[] tmpfeatures;
 293     String group = null, type;
 294     Vector visibleChecks = new Vector();
 295     AlignmentI alignment = av.getAlignment();
 296     for (int i = 0; i < alignment.getHeight(); i++)
 297     {
 298       if (alignment.getSequenceAt(i).getSequenceFeatures() == null)
 299       {
 300         continue;
 301       }
 302
 303       tmpfeatures = alignment.getSequenceAt(i).getSequenceFeatures();
 304       int index = 0;
 305       while (index < tmpfeatures.length)
 306       {
 307         group = tmpfeatures[index].featureGroup;
 308
 309         if (group == null || fr.featureGroups.get(group) == null
 310                 || ((Boolean) fr.featureGroups.get(group)).booleanValue())
 311         {
 312           type = tmpfeatures[index].getType();
 313           if (!visibleChecks.contains(type))
 314           {
 315             visibleChecks.addElement(type);
 316           }
 317         }
 318         index++;
 319       }
 320     }
 321
 322     Component[] comps;
 323     int cSize = featurePanel.getComponentCount();
 324     MyCheckbox check;
 325     // This will remove any checkboxes which shouldn't be
 326     // visible
 327     for (int i = 0; i < cSize; i++)
 328     {
 329       comps = featurePanel.getComponents();
 330       check = (MyCheckbox) comps[i];
 331       if (!visibleChecks.contains(check.type))
 332       {
 333         featurePanel.remove(i);
 334         cSize--;
 335         i--;
 336       }
 337     }
 338
 339     if (fr.renderOrder != null)
 340     {
 341       // First add the checks in the previous render order,
 342       // in case the window has been closed and reopened
 343       for (int ro = fr.renderOrder.length - 1; ro > -1; ro--)
 344       {
 345         String item = fr.renderOrder[ro];
 346
 347         if (!visibleChecks.contains(item))
 348         {
 349           continue;
 350         }
 351
 352         visibleChecks.removeElement(item);
 353
 354         addCheck(false, item);
 355       }
 356     }
 357
 358     // now add checkboxes which should be visible,
 359     // if they have not already been added
 360     Enumeration en = visibleChecks.elements();
 361
 362     while (en.hasMoreElements())
 363     {
 364       addCheck(groupsChanged, en.nextElement().toString());
 365     }
 366
 367     featurePanel.setLayout(new GridLayout(featurePanel.getComponentCount(),
 368             1, 10, 5));
 369     featurePanel.validate();
 370
 371     if (scrollPane != null)
 372     {
 373       scrollPane.validate();
 374     }
 375
 376     itemStateChanged(null);
 377   }
 378
 379   /**
 380    * update the checklist of feature types with the given type
 381    *
 382    * @param groupsChanged
 383    *          true means if the type is not in the display list then it will be
 384    *          added and displayed
 385    * @param type
 386    *          feature type to be checked for in the list.
 387    */
 388   void addCheck(boolean groupsChanged, String type)
 389   {
 390     boolean addCheck;
 391     Component[] comps = featurePanel.getComponents();
 392     MyCheckbox check;
 393     addCheck = true;
 394     for (int i = 0; i < featurePanel.getComponentCount(); i++)
 395     {
 396       check = (MyCheckbox) comps[i];
 397       if (check.type.equals(type))
 398       {
 399         addCheck = false;
 400         break;
 401       }
 402     }
 403
 404     if (addCheck)
 405     {
 406       boolean selected = false;
 407       if (groupsChanged || av.featuresDisplayed.containsKey(type))
 408       {
 409         selected = true;
 410       }
 411
 412       check = new MyCheckbox(
 413               type,
 414               selected,
 415               (fr.featureLinks != null && fr.featureLinks.containsKey(type)),
 416               fr.getFeatureStyle(type));
 417
 418       check.addMouseListener(this);
 419       check.addMouseMotionListener(this);
 420       check.addItemListener(this);
 421       if (groupsChanged)
 422       {
 423         // add at beginning of stack.
 424         featurePanel.add(check, 0);
 425       }
 426       else
 427       {
 428         // add at end of stack.
 429         featurePanel.add(check);
 430       }
 431     }
 432   }
 433
 434   public void actionPerformed(ActionEvent evt)
 435   {
 436     for (int i = 0; i < featurePanel.getComponentCount(); i++)
 437     {
 438       Checkbox check = (Checkbox) featurePanel.getComponent(i);
 439       check.setState(!check.getState());
 440     }
 441     selectionChanged();
 442   }
 443
 444   public void itemStateChanged(ItemEvent evt)
 445   {
 446     if (evt != null)
 447     {
 448       // Is the source a top level featureGroup?
 449       Checkbox source = (Checkbox) evt.getSource();
 450       if (fr.featureGroups.containsKey(source.getLabel()))
 451       {
 452         fr.featureGroups.put(source.getLabel(),
 453                 new Boolean(source.getState()));
 454         ap.seqPanel.seqCanvas.repaint();
 455         if (ap.overviewPanel != null)
 456         {
 457           ap.overviewPanel.updateOverviewImage();
 458         }
 459
 460         resetTable(true);
 461         return;
 462       }
 463     }
 464     selectionChanged();
 465   }
 466
 467   void selectionChanged()
 468   {
 469     Component[] comps = featurePanel.getComponents();
 470     int cSize = comps.length;
 471
 472     Object[][] tmp = new Object[cSize][3];
 473     int tmpSize = 0;
 474     for (int i = 0; i < cSize; i++)
 475     {
 476       MyCheckbox check = (MyCheckbox) comps[i];
 477       tmp[tmpSize][0] = check.type;
 478       tmp[tmpSize][1] = fr.getFeatureStyle(check.type);
 479       tmp[tmpSize][2] = new Boolean(check.getState());
 480       tmpSize++;
 481     }
 482
 483     Object[][] data = new Object[tmpSize][3];
 484     System.arraycopy(tmp, 0, data, 0, tmpSize);
 485
 486     fr.setFeaturePriority(data);
 487
 488     ap.paintAlignment(true);
 489   }
 490
 491   MyCheckbox selectedCheck;
 492
 493   boolean dragging = false;
 494
 495   public void mousePressed(MouseEvent evt)
 496   {
 497
 498     selectedCheck = (MyCheckbox) evt.getSource();
 499
 500     if (fr.featureLinks != null
 501             && fr.featureLinks.containsKey(selectedCheck.type))
 502     {
 503       if (evt.getX() > selectedCheck.stringWidth + 20)
 504       {
 505         evt.consume();
 506       }
 507     }
 508
 509   }
 510
 511   public void mouseDragged(MouseEvent evt)
 512   {
 513     if (((Component) evt.getSource()).getParent() != featurePanel)
 514     {
 515       return;
 516     }
 517     dragging = true;
 518   }
 519
 520   public void mouseReleased(MouseEvent evt)
 521   {
 522     if (((Component) evt.getSource()).getParent() != featurePanel)
 523     {
 524       return;
 525     }
 526
 527     Component comp = null;
 528     Checkbox target = null;
 529
 530     int height = evt.getY() + evt.getComponent().getLocation().y;
 531
 532     if (height > featurePanel.getSize().height)
 533     {
 534
 535       comp = featurePanel
 536               .getComponent(featurePanel.getComponentCount() - 1);
 537     }
 538     else if (height < 0)
 539     {
 540       comp = featurePanel.getComponent(0);
 541     }
 542     else
 543     {
 544       comp = featurePanel.getComponentAt(evt.getX(), evt.getY()
 545               + evt.getComponent().getLocation().y);
 546     }
 547
 548     if (comp != null && comp instanceof Checkbox)
 549     {
 550       target = (Checkbox) comp;
 551     }
 552
 553     if (selectedCheck != null && target != null && selectedCheck != target)
 554     {
 555       int targetIndex = -1;
 556       for (int i = 0; i < featurePanel.getComponentCount(); i++)
 557       {
 558         if (target == featurePanel.getComponent(i))
 559         {
 560           targetIndex = i;
 561           break;
 562         }
 563       }
 564
 565       featurePanel.remove(selectedCheck);
 566       featurePanel.add(selectedCheck, targetIndex);
 567       featurePanel.validate();
 568       itemStateChanged(null);
 569     }
 570   }
 571
 572   public void setUserColour(String feature, Object originalColour)
 573   {
 574     if (originalColour instanceof Color
 575             || originalColour instanceof GraduatedColor)
 576     {
 577       fr.setColour(feature, originalColour);
 578     }
 579     else
 580     {
 581       throw new Error(
 582               "Implementation error: Unsupported feature colour object.");
 583     }
 584     refreshTable();
 585   }
 586
 587   public void refreshTable()
 588   {
 589     featurePanel.removeAll();
 590     resetTable(false);
 591     ap.paintAlignment(true);
 592   }
 593
 594   public void mouseEntered(MouseEvent evt)
 595   {
 596   }
 597
 598   public void mouseExited(MouseEvent evt)
 599   {
 600   }
 601
 602   public void mouseClicked(MouseEvent evt)
 603   {
 604     MyCheckbox check = (MyCheckbox) evt.getSource();
 605     if ((evt.getModifiers() & InputEvent.BUTTON3_MASK) != 0)
 606     {
 607       this.popupSort(check, fr.minmax, evt.getX(), evt.getY());
 608     }
 609     if (fr.featureLinks != null && fr.featureLinks.containsKey(check.type))
 610     {
 611       if (evt.getX() > check.stringWidth + 20)
 612       {
 613         evt.consume();
 614         String link = fr.featureLinks.get(check.type).toString();
 615         ap.alignFrame.showURL(link.substring(link.indexOf("|") + 1),
 616                 link.substring(0, link.indexOf("|")));
 617       }
 618     }
 619
 620     if (check.getParent() != featurePanel)
 621     {
 622       return;
 623     }
 624
 625     if (evt.getClickCount() > 1)
 626     {
 627       Object fcol = fr.getFeatureStyle(check.type);
 628       if (fcol instanceof Color)
 629       {
 630         new UserDefinedColours(this, check.type, (Color) fcol);
 631       }
 632       else
 633       {
 634         new FeatureColourChooser(this, check.type);
 635         // write back the current colour object to update the table
 636         check.updateColor(fr.getFeatureStyle(check.type));
 637       }
 638     }
 639   }
 640
 641   public void mouseMoved(MouseEvent evt)
 642   {
 643   }
 644
 645   public void adjustmentValueChanged(AdjustmentEvent evt)
 646   {
 647     fr.transparency = ((float) (100 - transparency.getValue()) / 100f);
 648     ap.seqPanel.seqCanvas.repaint();
 649
 650   }
 651
 652   class MyCheckbox extends Checkbox
 653   {
 654     public String type;
 655
 656     public int stringWidth;
 657
 658     boolean hasLink;
 659
 660     GraduatedColor gcol;
 661
 662     Color col;
 663
 664     public void updateColor(Object newcol)
 665     {
 666       if (newcol instanceof Color)
 667       {
 668         col = (Color) newcol;
 669         gcol = null;
 670       }
 671       else if (newcol instanceof GraduatedColor)
 672       {
 673         gcol = (GraduatedColor) newcol;
 674         col = null;
 675       }
 676       else
 677       {
 678         throw new Error("Invalid color for MyCheckBox");
 679       }
 680       if (col != null)
 681       {
 682         setBackground(col);
 683       }
 684       else
 685       {
 686         String vlabel = type;
 687         if (gcol.getThreshType() != AnnotationColourGradient.NO_THRESHOLD)
 688         {
 689           vlabel += " "
 690                   + ((gcol.getThreshType() == AnnotationColourGradient.ABOVE_THRESHOLD) ? "(>)"
 691                           : "(<)");
 692         }
 693         if (gcol.isColourByLabel())
 694         {
 695           setBackground(Color.white);
 696           vlabel += " (by Label)";
 697         }
 698         else
 699         {
 700           setBackground(gcol.getMinColor());
 701         }
 702         this.setLabel(vlabel);
 703       }
 704       repaint();
 705     }
 706
 707     public MyCheckbox(String label, boolean checked, boolean haslink)
 708     {
 709       super(label, checked);
 710       type = label;
 711       FontMetrics fm = av.nullFrame.getFontMetrics(av.nullFrame.getFont());
 712       stringWidth = fm.stringWidth(label);
 713       this.hasLink = haslink;
 714     }
 715
 716     public MyCheckbox(String type, boolean selected, boolean b,
 717             Object featureStyle)
 718     {
 719       this(type, selected, b);
 720       updateColor(featureStyle);
 721     }
 722
 723     public void paint(Graphics g)
 724     {
 725       Dimension d = getSize();
 726       if (gcol != null)
 727       {
 728         if (gcol.isColourByLabel())
 729         {
 730           g.setColor(Color.white);
 731           g.fillRect(d.width / 2, 0, d.width / 2, d.height);
 732           /*
 733            * g.setColor(Color.black); Font f=g.getFont().deriveFont(9);
 734            * g.setFont(f);
 735            *
 736            * // g.setFont(g.getFont().deriveFont( //
 737            * AffineTransform.getScaleInstance( //
 738            * width/g.getFontMetrics().stringWidth("Label"), //
 739            * height/g.getFontMetrics().getHeight()))); g.drawString("Label",
 740            * width/2, 0);
 741            */
 742
 743         }
 744         else
 745         {
 746           Color maxCol = gcol.getMaxColor();
 747           g.setColor(maxCol);
 748           g.fillRect(d.width / 2, 0, d.width / 2, d.height);
 749
 750         }
 751       }
 752
 753       if (hasLink)
 754       {
 755         g.drawImage(linkImage, stringWidth + 25,
 756                 (getSize().height - linkImage.getHeight(this)) / 2, this);
 757       }
 758     }
 759   }
 760
 761   protected void sortByDens(String[] typ)
 762   {
 763     sortBy(typ, "Sort by Density", AlignmentSorter.FEATURE_DENSITY);
 764   }
 765
 766   private String[] getDisplayedFeatureTypes()
 767   {
 768     String[] typ = null;
 769     if (fr != null)
 770     {
 771       synchronized (fr.renderOrder)
 772       {
 773         typ = new String[fr.renderOrder.length];
 774         System.arraycopy(fr.renderOrder, 0, typ, 0, typ.length);
 775         for (int i = 0; i < typ.length; i++)
 776         {
 777           if (av.featuresDisplayed.get(typ[i]) == null)
 778           {
 779             typ[i] = null;
 780           }
 781         }
 782       }
 783     }
 784     return typ;
 785   }
 786
 787   protected void sortBy(String[] typ, String methodText, final String method)
 788   {
 789     if (typ == null)
 790     {
 791       typ = getDisplayedFeatureTypes();
 792     }
 793     String gps[] = null;
 794     gps = fr.getGroups(true);
 795     if (typ != null)
 796     {
 797       for (int i = 0; i < typ.length; i++)
 798       {
 799         System.err.println("Sorting on Types:" + typ[i]);
 800       }
 801     }
 802     if (gps != null)
 803     {
 804
 805       for (int i = 0; i < gps.length; i++)
 806       {
 807         System.err.println("Sorting on groups:" + gps[i]);
 808       }
 809     }
 810     AlignmentPanel alignPanel = ap;
 811     AlignmentI al = alignPanel.av.getAlignment();
 812
 813     int start, stop;
 814     SequenceGroup sg = alignPanel.av.getSelectionGroup();
 815     if (sg != null)
 816     {
 817       start = sg.getStartRes();
 818       stop = sg.getEndRes();
 819     }
 820     else
 821     {
 822       start = 0;
 823       stop = al.getWidth();
 824     }
 825     SequenceI[] oldOrder = al.getSequencesArray();
 826     AlignmentSorter.sortByFeature(typ, gps, start, stop, al, method);
 827     this.ap.alignFrame.addHistoryItem(new OrderCommand(methodText,
 828             oldOrder, alignPanel.av.getAlignment()));
 829     alignPanel.paintAlignment(true);
 830
 831   }
 832
 833   protected void sortByScore(String[] typ)
 834   {
 835     sortBy(typ, "Sort by Feature Score", AlignmentSorter.FEATURE_SCORE);
 836   }
 837
 838 }