src/jalview/appletgui/AlignFrame.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer
   3  * Copyright (C) 2006 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
  20 package jalview.appletgui;
  21
  22 import jalview.schemes.*;
  23 import jalview.datamodel.*;
  24 import jalview.analysis.*;
  25 import jalview.io.*;
  26 import java.awt.*;
  27 import java.awt.event.*;
  28 import java.util.*;
  29 import java.io.InputStreamReader;
  30 import java.io.BufferedReader;
  31 import java.net.URL;
  32
  33
  34 public class AlignFrame extends Frame implements ActionListener,
  35     ItemListener, KeyListener, MouseListener
  36 {
  37   public AlignmentPanel alignPanel;
  38   public AlignViewport viewport;
  39   int NEW_WINDOW_WIDTH = 700;
  40   int NEW_WINDOW_HEIGHT = 500;
  41
  42   String jalviewServletURL;
  43
  44
  45    public AlignFrame(AlignmentI al,
  46                      jalview.bin.JalviewLite applet,
  47                      String title,
  48                      boolean embedded)
  49   {
  50
  51     jalviewServletURL = applet.getParameter("APPLICATION_URL");
  52
  53     try{
  54       jbInit();
  55     }catch(Exception ex)
  56     {
  57       ex.printStackTrace();
  58     }
  59
  60     viewport = new AlignViewport(al, applet);
  61     alignPanel = new AlignmentPanel(this, viewport);
  62
  63     annotationPanelMenuItem.setState(viewport.showAnnotation);
  64
  65     seqLimits.setState(viewport.showJVSuffix);
  66
  67     if(applet!=null)
  68     {
  69       String param = applet.getParameter("sortBy");
  70       if (param != null)
  71       {
  72         if (param.equalsIgnoreCase("Id"))
  73           sortIDMenuItem_actionPerformed();
  74         else if (param.equalsIgnoreCase("Pairwise Identity"))
  75           sortPairwiseMenuItem_actionPerformed();
  76       }
  77
  78       param = applet.getParameter("wrap");
  79       if (param != null)
  80       {
  81         if (param.equalsIgnoreCase("true"))
  82         {
  83           wrapMenuItem.setState(true);
  84           wrapMenuItem_actionPerformed();
  85         }
  86       }
  87
  88       try
  89       {
  90         param = applet.getParameter("windowWidth");
  91         if (param != null)
  92         {
  93           int width = Integer.parseInt(param);
  94           NEW_WINDOW_WIDTH = width;
  95         }
  96         param = applet.getParameter("windowHeight");
  97         if (param != null)
  98         {
  99           int height = Integer.parseInt(param);
 100           NEW_WINDOW_HEIGHT = height;
 101         }
 102       }
 103       catch (Exception ex)
 104       {}
 105
 106     }
 107
 108    //Some JVMS send keyevents to Top frame or lowest panel,
 109    //Havent worked out why yet. So add to both this frame and seqCanvas for now
 110    this.addKeyListener(this);
 111    alignPanel.seqPanel.seqCanvas.addKeyListener(this);
 112    alignPanel.idPanel.idCanvas.addKeyListener(this);
 113    alignPanel.scalePanel.addKeyListener(this);
 114    alignPanel.annotationPanel.addKeyListener(this);
 115
 116     viewport.addPropertyChangeListener(new java.beans.PropertyChangeListener()
 117     {
 118      public void propertyChange(java.beans.PropertyChangeEvent evt)
 119      {
 120        if (evt.getPropertyName().equals("alignment"))
 121        {
 122          alignmentChanged();
 123        }
 124      }
 125    });
 126
 127
 128    if(embedded)
 129    {
 130      setEmbedded();
 131    }
 132    else
 133    {
 134      add(alignPanel, BorderLayout.CENTER);
 135      jalview.bin.JalviewLite.addFrame(this, title, NEW_WINDOW_WIDTH,
 136                                       NEW_WINDOW_HEIGHT);
 137    }
 138    alignPanel.validate();
 139    alignPanel.repaint();
 140   }
 141   public AlignViewport getAlignViewport()
 142   {
 143     return viewport;
 144   }
 145
 146   public SeqCanvas getSeqcanvas()
 147   {
 148     return alignPanel.seqPanel.seqCanvas;
 149   }
 150
 151
 152   /**
 153    * DOCUMENT ME!
 154    *
 155    * @param String DOCUMENT ME!
 156    */
 157
 158   public void parseFeaturesFile(String file, String type)
 159   {
 160     Hashtable featureLinks = new Hashtable();
 161     boolean featuresFile = false;
 162     try{
 163       featuresFile = new jalview.io.FeaturesFile(file, type).parse(viewport.alignment,
 164                                          alignPanel.seqPanel.seqCanvas.
 165                                          getFeatureRenderer().featureColours,
 166                                          featureLinks,
 167                                          true);
 168     }
 169     catch(Exception ex)
 170     {
 171       ex.printStackTrace();
 172     }
 173
 174     if(featuresFile)
 175     {
 176       if(featureLinks.size()>0)
 177         alignPanel.seqPanel.seqCanvas
 178             .getFeatureRenderer().featureLinks = featureLinks;
 179       viewport.showSequenceFeatures = true;
 180       sequenceFeatures.setState(true);
 181       alignPanel.repaint();
 182     }
 183
 184   }
 185
 186
 187   public void keyPressed(KeyEvent evt)
 188   {
 189     if (viewport.cursorMode
 190         && evt.getKeyCode() >= KeyEvent.VK_0
 191         && evt.getKeyCode() <= KeyEvent.VK_9)
 192     {
 193       alignPanel.seqPanel.numberPressed(evt.getKeyChar());
 194     }
 195
 196     switch (evt.getKeyCode())
 197     {
 198       case 27: // escape key
 199         deselectAllSequenceMenuItem_actionPerformed();
 200         break;
 201       case KeyEvent.VK_X:
 202         if (evt.isControlDown() || evt.isMetaDown())
 203         {
 204           cut_actionPerformed();
 205         }
 206         break;
 207       case KeyEvent.VK_C:
 208         if (viewport.cursorMode && !evt.isControlDown())
 209         {
 210           alignPanel.seqPanel.setCursorColumn();
 211         }
 212         if (evt.isControlDown() || evt.isMetaDown())
 213         {
 214           copy_actionPerformed();
 215         }
 216         break;
 217       case KeyEvent.VK_V:
 218         if (evt.isControlDown() || evt.isMetaDown())
 219         {
 220           paste(true);
 221         }
 222         break;
 223       case KeyEvent.VK_A:
 224         if (evt.isControlDown() || evt.isMetaDown())
 225         {
 226           selectAllSequenceMenuItem_actionPerformed();
 227         }
 228         break;
 229       case KeyEvent.VK_DOWN:
 230         if(viewport.cursorMode)
 231         {
 232           alignPanel.seqPanel.moveCursor(0,1);
 233         }
 234         else
 235           moveSelectedSequences(false);
 236         break;
 237
 238       case KeyEvent.VK_UP:
 239         if (viewport.cursorMode)
 240         {
 241           alignPanel.seqPanel.moveCursor(0,-1);
 242         }
 243         else
 244           moveSelectedSequences(true);
 245         break;
 246
 247       case KeyEvent.VK_LEFT:
 248         if(viewport.cursorMode)
 249         {
 250           alignPanel.seqPanel.moveCursor(-1,0);
 251         }
 252         break;
 253
 254       case KeyEvent.VK_RIGHT:
 255         if (viewport.cursorMode)
 256         {
 257           alignPanel.seqPanel.moveCursor(1,0);
 258         }
 259         break;
 260       case KeyEvent.VK_SPACE:
 261         if(viewport.cursorMode)
 262         {
 263           alignPanel.seqPanel.insertGapAtCursor(evt.isControlDown());
 264         }
 265         break;
 266
 267       case KeyEvent.VK_DELETE:
 268       case KeyEvent.VK_BACK_SPACE:
 269         if(viewport.cursorMode)
 270         {
 271           alignPanel.seqPanel.deleteGapAtCursor(evt.isControlDown());
 272         }
 273        else
 274         {
 275           cut_actionPerformed();
 276           alignPanel.seqPanel.seqCanvas.repaint();
 277         }
 278         break;
 279
 280       case KeyEvent.VK_S:
 281         if(viewport.cursorMode)
 282         {
 283           alignPanel.seqPanel.setCursorRow();
 284         }
 285         break;
 286       case KeyEvent.VK_P:
 287         if(viewport.cursorMode)
 288         {
 289           alignPanel.seqPanel.setCursorPosition();
 290         }
 291         break;
 292
 293       case KeyEvent.VK_ENTER:
 294       case KeyEvent.VK_COMMA:
 295         if(viewport.cursorMode)
 296         {
 297           alignPanel.seqPanel.setCursorRowAndColumn();
 298         }
 299         break;
 300
 301       case KeyEvent.VK_Q:
 302         if(viewport.cursorMode)
 303         {
 304           alignPanel.seqPanel.setSelectionAreaAtCursor(true);
 305         }
 306         break;
 307       case KeyEvent.VK_M:
 308         if(viewport.cursorMode)
 309         {
 310           alignPanel.seqPanel.setSelectionAreaAtCursor(false);
 311         }
 312         break;
 313
 314      case KeyEvent.VK_F2:
 315        viewport.cursorMode = ! viewport.cursorMode;
 316        statusBar.setText("Keyboard editing mode is "+
 317            (viewport.cursorMode ? "on" : "off"));
 318        if(viewport.cursorMode)
 319        {
 320          alignPanel.seqPanel.seqCanvas.cursorX = viewport.startRes;
 321          alignPanel.seqPanel.seqCanvas.cursorY = viewport.startSeq;
 322        }
 323        alignPanel.seqPanel.seqCanvas.repaint();
 324        break;
 325
 326       case KeyEvent.VK_F:
 327         if (evt.isControlDown())
 328         {
 329           findMenuItem_actionPerformed();
 330         }
 331         break;
 332       case KeyEvent.VK_H:
 333       {
 334         boolean toggleSeqs = !evt.isControlDown();
 335         boolean toggleCols = !evt.isShiftDown();
 336         boolean hide = false;
 337         SequenceGroup sg = viewport.getSelectionGroup();
 338
 339         if(toggleSeqs)
 340         {
 341           if (sg != null && sg.getSize(false) != viewport.alignment.getHeight())
 342           {
 343             hide = true;
 344             viewport.hideAllSelectedSeqs();
 345           }
 346           else if (!(toggleCols && viewport.colSel.getSelected().size() > 0))
 347             viewport.showAllHiddenSeqs();
 348         }
 349
 350         if(toggleCols)
 351         {
 352           if (viewport.colSel.getSelected().size() > 0)
 353           {
 354             viewport.hideSelectedColumns();
 355             if(!toggleSeqs)
 356                    viewport.selectionGroup = sg;
 357           }
 358           else if (!hide)
 359             viewport.showAllHiddenColumns();
 360         }
 361
 362         alignPanel.repaint();
 363         break;
 364       }
 365
 366     }
 367   }
 368   public void keyReleased(KeyEvent evt)
 369   {}
 370   public void keyTyped(KeyEvent evt)
 371   {}
 372
 373 public void itemStateChanged(ItemEvent evt)
 374   {
 375     if(evt.getSource()==colourTextMenuItem)
 376             colourTextMenuItem_actionPerformed();
 377     else if(evt.getSource()==wrapMenuItem)
 378             wrapMenuItem_actionPerformed();
 379     else if(evt.getSource()==scaleAbove)
 380             scaleAbove_actionPerformed();
 381     else if(evt.getSource()==scaleLeft)
 382             scaleLeft_actionPerformed();
 383     else if(evt.getSource()==scaleRight)
 384             scaleRight_actionPerformed();
 385      else if(evt.getSource()==seqLimits)
 386       seqLimits_itemStateChanged();
 387     else if(evt.getSource()==viewBoxesMenuItem)
 388             viewBoxesMenuItem_actionPerformed();
 389     else if(evt.getSource()==viewTextMenuItem)
 390             viewTextMenuItem_actionPerformed();
 391     else if(evt.getSource()==renderGapsMenuItem)
 392             renderGapsMenuItem_actionPerformed();
 393     else if(evt.getSource()==annotationPanelMenuItem)
 394             annotationPanelMenuItem_actionPerformed();
 395       else if(evt.getSource()==sequenceFeatures)
 396       {
 397            viewport.showSequenceFeatures(sequenceFeatures.getState());
 398             alignPanel.seqPanel.seqCanvas.repaint();
 399       }
 400       else if(evt.getSource()==conservationMenuItem)
 401             conservationMenuItem_actionPerformed();
 402       else if(evt.getSource()==abovePIDThreshold)
 403             abovePIDThreshold_actionPerformed();
 404           else if(evt.getSource()==applyToAllGroups)
 405             applyToAllGroups_actionPerformed();
 406       else if(evt.getSource()==autoCalculate)
 407           viewport.autocalculateConsensus = autoCalculate.getState();
 408   }
 409  public void actionPerformed(ActionEvent evt)
 410  {
 411     Object source = evt.getSource();
 412
 413     if(source==inputText)
 414       inputText_actionPerformed();
 415     else if(source==loadTree)
 416       loadTree_actionPerformed();
 417     else if(source==loadApplication)
 418       launchFullApplication();
 419     else if(source==closeMenuItem)
 420       closeMenuItem_actionPerformed();
 421     else if(source==copy)
 422       copy_actionPerformed();
 423     else if(source==undoMenuItem)
 424       undoMenuItem_actionPerformed();
 425     else if(source==redoMenuItem)
 426       redoMenuItem_actionPerformed();
 427     else if(source==inputText)
 428             inputText_actionPerformed();
 429     else if(source==closeMenuItem)
 430             closeMenuItem_actionPerformed();
 431     else if(source==undoMenuItem)
 432             undoMenuItem_actionPerformed();
 433     else if(source==redoMenuItem)
 434             redoMenuItem_actionPerformed();
 435     else if(source==copy)
 436             copy_actionPerformed();
 437     else if(source==pasteNew)
 438             pasteNew_actionPerformed();
 439     else if(source==pasteThis)
 440             pasteThis_actionPerformed();
 441     else if(source==cut)
 442             cut_actionPerformed();
 443     else if(source==delete)
 444             delete_actionPerformed();
 445     else if(source==deleteGroups)
 446             deleteGroups_actionPerformed();
 447     else if(source==selectAllSequenceMenuItem)
 448             selectAllSequenceMenuItem_actionPerformed();
 449     else if(source==deselectAllSequenceMenuItem)
 450             deselectAllSequenceMenuItem_actionPerformed();
 451     else if(source==invertSequenceMenuItem)
 452             invertSequenceMenuItem_actionPerformed();
 453     else if(source==invertColSel)
 454     { viewport.invertColumnSelection(); alignPanel.repaint(); }
 455     else if(source==remove2LeftMenuItem)
 456             remove2LeftMenuItem_actionPerformed();
 457     else if(source==remove2RightMenuItem)
 458             remove2RightMenuItem_actionPerformed();
 459     else if(source==removeGappedColumnMenuItem)
 460             removeGappedColumnMenuItem_actionPerformed();
 461     else if(source==removeAllGapsMenuItem)
 462             removeAllGapsMenuItem_actionPerformed();
 463     else if(source==findMenuItem)
 464             findMenuItem_actionPerformed();
 465     else if(source==font)
 466             font_actionPerformed();
 467     else if(source==showColumns)
 468     {
 469       viewport.showAllHiddenColumns(); alignPanel.repaint();
 470     }
 471     else if(source==showSeqs)
 472     {
 473       viewport.showAllHiddenSeqs();
 474     }
 475     else if(source == hideColumns)
 476     {
 477       viewport.hideSelectedColumns(); alignPanel.repaint();
 478     }
 479     else if(source == hideSequences && viewport.getSelectionGroup()!=null)
 480     {
 481       viewport.hideAllSelectedSeqs();
 482     }
 483     else if(source==featureSettings)
 484             featureSettings_actionPerformed();
 485     else if(source==overviewMenuItem)
 486             overviewMenuItem_actionPerformed();
 487     else if(source==noColourmenuItem)
 488             noColourmenuItem_actionPerformed();
 489     else if(source==clustalColour)
 490             clustalColour_actionPerformed();
 491     else if(source==zappoColour)
 492             zappoColour_actionPerformed();
 493     else if(source==taylorColour)
 494             taylorColour_actionPerformed();
 495     else if(source==hydrophobicityColour)
 496             hydrophobicityColour_actionPerformed();
 497     else if(source==helixColour)
 498             helixColour_actionPerformed();
 499     else if(source==strandColour)
 500             strandColour_actionPerformed();
 501     else if(source==turnColour)
 502             turnColour_actionPerformed();
 503     else if(source==buriedColour)
 504             buriedColour_actionPerformed();
 505     else if(source==nucleotideColour)
 506             nucleotideColour_actionPerformed();
 507     else if(source==modifyPID)
 508             modifyPID_actionPerformed();
 509     else if(source==modifyConservation)
 510             modifyConservation_actionPerformed();
 511     else if(source==userDefinedColour)
 512             userDefinedColour_actionPerformed();
 513     else if(source==PIDColour)
 514             PIDColour_actionPerformed();
 515     else if(source==BLOSUM62Colour)
 516             BLOSUM62Colour_actionPerformed();
 517     else if(source==annotationColour)
 518            new AnnotationColourChooser(viewport, alignPanel);
 519     else if(source==sortPairwiseMenuItem)
 520             sortPairwiseMenuItem_actionPerformed();
 521     else if(source==sortIDMenuItem)
 522             sortIDMenuItem_actionPerformed();
 523     else if(source==sortGroupMenuItem)
 524             sortGroupMenuItem_actionPerformed();
 525     else if(source==removeRedundancyMenuItem)
 526             removeRedundancyMenuItem_actionPerformed();
 527     else if(source==pairwiseAlignmentMenuItem)
 528             pairwiseAlignmentMenuItem_actionPerformed();
 529     else if(source==PCAMenuItem)
 530             PCAMenuItem_actionPerformed();
 531     else if(source==averageDistanceTreeMenuItem)
 532             averageDistanceTreeMenuItem_actionPerformed();
 533     else if(source==neighbourTreeMenuItem)
 534             neighbourTreeMenuItem_actionPerformed();
 535     else if(source==njTreeBlosumMenuItem)
 536             njTreeBlosumMenuItem_actionPerformed();
 537     else if(source==avDistanceTreeBlosumMenuItem)
 538             avTreeBlosumMenuItem_actionPerformed();
 539     else if(source==documentation)
 540             documentation_actionPerformed();
 541     else if(source==about)
 542             about_actionPerformed();
 543
 544  }
 545
 546   public void inputText_actionPerformed()
 547   {
 548     CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
 549     Frame frame = new Frame();
 550     frame.add(cap);
 551     jalview.bin.JalviewLite.addFrame(frame, "Cut & Paste Input", 500, 500);
 552   }
 553
 554   protected void outputText_actionPerformed(ActionEvent e)
 555   {
 556     CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this);
 557     Frame frame = new Frame();
 558     frame.add(cap);
 559     jalview.bin.JalviewLite.addFrame(frame,
 560                                      "Alignment output - " + e.getActionCommand(),
 561                                      600, 500);
 562     cap.setText(new AppletFormatAdapter().formatSequences(e.getActionCommand(),
 563                                               viewport.getAlignment().getSequences(),
 564                                                       viewport.showJVSuffix));
 565   }
 566
 567   void launchFullApplication()
 568   {
 569     StringBuffer url = new StringBuffer(jalviewServletURL);
 570
 571     url.append("?open="+
 572                appendProtocol( viewport.applet.getParameter("file") ) );
 573
 574     if(viewport.applet.getParameter("features")!=null)
 575     {
 576       url.append( "&features=" );
 577       url.append( appendProtocol( viewport.applet.getParameter("features") ) );
 578     }
 579
 580     if(viewport.applet.getParameter("annotations")!=null)
 581     {
 582       url.append( "&annotations=" );
 583       url.append( appendProtocol( viewport.applet.getParameter("annotations") ) );
 584     }
 585
 586     if(viewport.applet.getParameter("jnetfile")!=null)
 587     {
 588       url.append( "&annotations=" );
 589       url.append( appendProtocol( viewport.applet.getParameter("jnetfile") ) );
 590     }
 591
 592     if(viewport.applet.getParameter("defaultColour")!=null)
 593     {
 594       url.append("&colour=" +
 595                  removeWhiteSpace(viewport.applet.getParameter("defaultColour"))
 596           );
 597     }
 598
 599     if(viewport.applet.getParameter("userDefinedColour")!=null)
 600     {
 601       url.append( "&colour=" +
 602                  removeWhiteSpace( viewport.applet.getParameter("userDefinedColour") )
 603          );
 604     }
 605
 606     showURL(url.toString(), "FULL_APP");
 607   }
 608
 609
 610   String removeWhiteSpace(String colour)
 611   {
 612     StringBuffer sb = new StringBuffer();
 613     for (int i = 0; i < colour.length(); i++)
 614     {
 615       if (Character.isWhitespace(colour.charAt(i)))
 616         sb.append("%20");
 617       else
 618         sb.append(colour.charAt(i));
 619     }
 620
 621     return sb.toString();
 622   }
 623
 624
 625   String appendProtocol(String url)
 626   {
 627     try{
 628        new URL(url);
 629     }catch(java.net.MalformedURLException ex)
 630     {
 631       url = viewport.applet.getCodeBase()+url;
 632     }
 633     return url;
 634   }
 635
 636   public void closeMenuItem_actionPerformed()
 637   {
 638     PaintRefresher.components.remove(viewport.alignment);
 639     if(PaintRefresher.components.size()==0 && viewport.applet==null)
 640       System.exit(0);
 641
 642     this.dispose();
 643   }
 644
 645   Stack historyList = new Stack();
 646   Stack redoList = new Stack();
 647
 648   void updateEditMenuBar()
 649   {
 650     if (historyList.size() > 0)
 651     {
 652       undoMenuItem.setEnabled(true);
 653       HistoryItem hi = (HistoryItem) historyList.peek();
 654       undoMenuItem.setLabel("Undo " + hi.getDescription());
 655     }
 656     else
 657     {
 658       undoMenuItem.setEnabled(false);
 659       undoMenuItem.setLabel("Undo");
 660     }
 661
 662     if (redoList.size() > 0)
 663     {
 664       redoMenuItem.setEnabled(true);
 665       HistoryItem hi = (HistoryItem) redoList.peek();
 666       redoMenuItem.setLabel("Redo " + hi.getDescription());
 667     }
 668     else
 669     {
 670       redoMenuItem.setEnabled(false);
 671       redoMenuItem.setLabel("Redo");
 672     }
 673   }
 674
 675   public void addHistoryItem(HistoryItem hi)
 676   {
 677     historyList.push(hi);
 678     redoList.removeAllElements();
 679     updateEditMenuBar();
 680   }
 681
 682   protected void undoMenuItem_actionPerformed()
 683   {
 684     HistoryItem nh,hi = (HistoryItem) historyList.pop();
 685     redoList.push(nh=new HistoryItem(hi.getDescription(), viewport.alignment,
 686                                   HistoryItem.HIDE));
 687     if (hi.alColumnChanges!=null)
 688       nh.alColumnChanges=hi.alColumnChanges.getInverse();
 689     restoreHistoryItem(hi);
 690     viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
 691   }
 692
 693   protected void redoMenuItem_actionPerformed()
 694   {
 695     HistoryItem nh,hi = (HistoryItem) redoList.pop();
 696     historyList.push(nh=new HistoryItem(hi.getDescription(), viewport.alignment,
 697                                   HistoryItem.HIDE));
 698     if (hi.alColumnChanges!=null)
 699       nh.alColumnChanges=hi.alColumnChanges.getInverse();
 700     restoreHistoryItem(hi);
 701     updateEditMenuBar();
 702     viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
 703   }
 704
 705   // used by undo and redo
 706   void restoreHistoryItem(HistoryItem hi)
 707   {
 708     hi.restore(viewport.getColumnSelection());
 709     updateEditMenuBar();
 710
 711     viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
 712   }
 713
 714   public void moveSelectedSequences(boolean up)
 715   {
 716     SequenceGroup sg = viewport.getSelectionGroup();
 717     if (sg == null)
 718     {
 719       return;
 720     }
 721
 722     if (up)
 723     {
 724       for (int i = 1; i < viewport.alignment.getHeight(); i++)
 725       {
 726         SequenceI seq = viewport.alignment.getSequenceAt(i);
 727         if (!sg.getSequences(false).contains(seq))
 728         {
 729           continue;
 730         }
 731
 732         SequenceI temp = viewport.alignment.getSequenceAt(i - 1);
 733         if (sg.getSequences(false).contains(temp))
 734         {
 735           continue;
 736         }
 737
 738         viewport.alignment.getSequences().setElementAt(temp, i);
 739         viewport.alignment.getSequences().setElementAt(seq, i - 1);
 740       }
 741     }
 742     else
 743     {
 744       for (int i = viewport.alignment.getHeight() - 2; i > -1; i--)
 745       {
 746         SequenceI seq = viewport.alignment.getSequenceAt(i);
 747         if (!sg.getSequences(true).contains(seq))
 748         {
 749           continue;
 750         }
 751
 752         SequenceI temp = viewport.alignment.getSequenceAt(i + 1);
 753         if (sg.getSequences(true).contains(temp))
 754         {
 755           continue;
 756         }
 757
 758         viewport.alignment.getSequences().setElementAt(temp, i);
 759         viewport.alignment.getSequences().setElementAt(seq, i + 1);
 760       }
 761     }
 762
 763     alignPanel.repaint();
 764   }
 765
 766   static StringBuffer copiedSequences;
 767   static Vector copiedHiddenColumns;
 768   protected void copy_actionPerformed()
 769   {
 770     if (viewport.getSelectionGroup() == null)
 771     {
 772       return;
 773     }
 774
 775     SequenceGroup sg = viewport.getSelectionGroup();
 776     copiedSequences = new StringBuffer();
 777     Hashtable orderedSeqs = new Hashtable();
 778     for (int i = 0; i < sg.getSize(false); i++)
 779     {
 780       SequenceI seq = sg.getSequenceAt(i);
 781       int index = viewport.alignment.findIndex(seq);
 782       orderedSeqs.put(index + "", seq);
 783     }
 784
 785     int index = 0, startRes, endRes;
 786     char ch;
 787
 788     if (viewport.hasHiddenColumns && viewport.getSelectionGroup() != null)
 789     {
 790       copiedHiddenColumns = new Vector();
 791       int hiddenOffset = viewport.getSelectionGroup().getStartRes();
 792       for (int i = 0; i < viewport.getColumnSelection().getHiddenColumns().size();
 793            i++)
 794       {
 795         int[] region = (int[])
 796             viewport.getColumnSelection().getHiddenColumns().elementAt(i);
 797
 798         copiedHiddenColumns.addElement(new int[]
 799                                  {region[0] - hiddenOffset,
 800                                  region[1] - hiddenOffset});
 801       }
 802     }
 803     else
 804       copiedHiddenColumns = null;
 805
 806
 807     for (int i = 0; i < sg.getSize(false); i++)
 808     {
 809         SequenceI seq = null;
 810
 811         while (seq == null)
 812         {
 813             if (orderedSeqs.containsKey(index + ""))
 814             {
 815                 seq = (SequenceI) orderedSeqs.get(index + "");
 816                 index++;
 817
 818                 break;
 819             }
 820             else
 821             {
 822                 index++;
 823             }
 824         }
 825
 826         //FIND START RES
 827         //Returns residue following index if gap
 828         startRes = seq.findPosition(sg.getStartRes());
 829
 830         //FIND END RES
 831         //Need to find the residue preceeding index if gap
 832         endRes = 0;
 833
 834         for (int j = 0; j < sg.getEndRes()+1 && j < seq.getLength(); j++)
 835         {
 836           ch = seq.getCharAt(j);
 837           if (!jalview.util.Comparison.isGap( (ch)))
 838           {
 839             endRes++;
 840           }
 841         }
 842
 843         if(endRes>0)
 844         {
 845           endRes += seq.getStart() -1;
 846         }
 847
 848         copiedSequences.append(seq.getName() + "\t" +
 849             startRes + "\t" +
 850             endRes + "\t" +
 851             seq.getSequence(sg.getStartRes(),
 852                 sg.getEndRes() + 1) + "\n");
 853     }
 854
 855   }
 856
 857   protected void pasteNew_actionPerformed()
 858   {
 859     paste(true);
 860   }
 861
 862   protected void pasteThis_actionPerformed()
 863   {
 864     addHistoryItem(new HistoryItem("Paste Sequences", viewport.alignment,
 865                                    HistoryItem.PASTE));
 866     paste(false);
 867   }
 868
 869   void paste(boolean newAlignment)
 870   {
 871     try
 872     {
 873       if (copiedSequences == null)
 874       {
 875         return;
 876       }
 877
 878       StringTokenizer st = new StringTokenizer(copiedSequences.toString());
 879       Vector seqs = new Vector();
 880       while (st.hasMoreElements())
 881       {
 882         String name = st.nextToken();
 883         int start = Integer.parseInt(st.nextToken());
 884         int end = Integer.parseInt(st.nextToken());
 885         Sequence sequence = new Sequence(name, st.nextToken(), start, end);
 886
 887         if (!newAlignment)
 888         {
 889           viewport.alignment.addSequence(sequence);
 890         }
 891         else
 892         {
 893           seqs.addElement(sequence);
 894         }
 895       }
 896
 897       if (newAlignment)
 898       {
 899         SequenceI[] newSeqs = new SequenceI[seqs.size()];
 900         for (int i = 0; i < seqs.size(); i++)
 901         {
 902           newSeqs[i] = (SequenceI) seqs.elementAt(i);
 903         }
 904
 905         String newtitle = new String("Copied sequences");
 906         if (getTitle().startsWith("Copied sequences"))
 907         {
 908           newtitle = getTitle();
 909         }
 910         else
 911         {
 912           newtitle = newtitle.concat("- from " + getTitle());
 913         }
 914         AlignFrame af = new AlignFrame(new Alignment(newSeqs),
 915                                        viewport.applet,
 916                                        newtitle,
 917                                        false);
 918         if (copiedHiddenColumns != null)
 919         {
 920           for (int i = 0; i < copiedHiddenColumns.size(); i++)
 921           {
 922             int[] region = (int[]) copiedHiddenColumns.elementAt(i);
 923             af.viewport.hideColumns(region[0], region[1]);
 924           }
 925         }
 926
 927
 928         jalview.bin.JalviewLite.addFrame(af, newtitle, NEW_WINDOW_WIDTH,
 929                                          NEW_WINDOW_HEIGHT);
 930       }
 931       else
 932       {
 933         viewport.setEndSeq(viewport.alignment.getHeight());
 934         viewport.alignment.getWidth();
 935         viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
 936       }
 937
 938     }
 939     catch (Exception ex)
 940     {} // could be anything being pasted in here
 941
 942   }
 943
 944   protected void cut_actionPerformed()
 945   {
 946     copy_actionPerformed();
 947     delete_actionPerformed();
 948   }
 949
 950   protected void delete_actionPerformed()
 951   {
 952     addHistoryItem(new HistoryItem("Delete Sequences", viewport.alignment,
 953                                    HistoryItem.HIDE));
 954     if (viewport.getSelectionGroup() == null)
 955     {
 956       return;
 957     }
 958
 959
 960     SequenceGroup sg = viewport.getSelectionGroup();
 961     boolean allSequences = false;
 962     if(sg.getSize(false)==viewport.alignment.getHeight())
 963           allSequences = true;
 964
 965     for (int i = 0; i < sg.getSize(false); i++)
 966     {
 967       SequenceI seq = sg.getSequenceAt(i);
 968       int index = viewport.getAlignment().findIndex(seq);
 969       seq.deleteChars(sg.getStartRes(), sg.getEndRes() + 1);
 970
 971       // If the cut affects all sequences, remove highlighted columns
 972       if (allSequences)
 973       {
 974         viewport.getColumnSelection().removeElements(sg.getStartRes(),
 975                                                      sg.getEndRes() + 1);
 976       }
 977
 978
 979       if (seq.getSequence().length() < 1)
 980       {
 981         viewport.getAlignment().deleteSequence(seq);
 982       }
 983       else
 984       {
 985         viewport.getAlignment().getSequences().setElementAt(seq, index);
 986       }
 987     }
 988
 989     viewport.setSelectionGroup(null);
 990     viewport.alignment.deleteGroup(sg);
 991     viewport.resetSeqLimits(alignPanel.seqPanel.seqCanvas.getSize().height);
 992     if (viewport.getAlignment().getHeight() < 1)
 993     {
 994       try
 995       {
 996         this.setVisible(false);
 997       }
 998       catch (Exception ex)
 999       {}
1000     }
1001     viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
1002
1003   }
1004
1005   protected void deleteGroups_actionPerformed()
1006   {
1007     viewport.alignment.deleteAllGroups();
1008     viewport.setSelectionGroup(null);
1009
1010     alignPanel.repaint();
1011   }
1012
1013   public void selectAllSequenceMenuItem_actionPerformed()
1014   {
1015     SequenceGroup sg = new SequenceGroup();
1016     for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
1017     {
1018       sg.addSequence(viewport.getAlignment().getSequenceAt(i), false);
1019     }
1020     sg.setEndRes(viewport.alignment.getWidth()-1);
1021     viewport.setSelectionGroup(sg);
1022     alignPanel.repaint();
1023     PaintRefresher.Refresh(null, viewport.alignment);
1024   }
1025
1026   public void deselectAllSequenceMenuItem_actionPerformed()
1027   {
1028     if(viewport.cursorMode)
1029     {
1030       alignPanel.seqPanel.keyboardNo1=null;
1031       alignPanel.seqPanel.keyboardNo2=null;
1032     }
1033     viewport.setSelectionGroup(null);
1034     viewport.getColumnSelection().clear();
1035     viewport.setSelectionGroup(null);
1036     alignPanel.idPanel.idCanvas.searchResults = null;
1037     alignPanel.seqPanel.seqCanvas.highlightSearchResults(null);
1038     alignPanel.repaint();
1039     PaintRefresher.Refresh(null, viewport.alignment);
1040   }
1041
1042   public void invertSequenceMenuItem_actionPerformed()
1043   {
1044     SequenceGroup sg = viewport.getSelectionGroup();
1045     for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++)
1046     {
1047       sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false);
1048     }
1049
1050     PaintRefresher.Refresh(null, viewport.alignment);
1051   }
1052
1053   public void remove2LeftMenuItem_actionPerformed()
1054   {
1055     ColumnSelection colSel = viewport.getColumnSelection();
1056     if (colSel.size() > 0)
1057     {
1058       HistoryItem edit;
1059       addHistoryItem(edit=new HistoryItem("Remove Left", viewport.alignment,
1060                                      HistoryItem.HIDE));
1061       int min = colSel.getMin();
1062       viewport.getAlignment().trimLeft(min);
1063       colSel.compensateForEdit(0, min);
1064       edit.addShift(0, min);
1065       if (viewport.getSelectionGroup() != null)
1066       {
1067         viewport.getSelectionGroup().adjustForRemoveLeft(min);
1068       }
1069
1070       Vector groups = viewport.alignment.getGroups();
1071       for (int i = 0; i < groups.size(); i++)
1072       {
1073         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
1074         if (!sg.adjustForRemoveLeft(min))
1075         {
1076           viewport.alignment.deleteGroup(sg);
1077         }
1078       }
1079       viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
1080     }
1081   }
1082
1083   public void remove2RightMenuItem_actionPerformed()
1084   {
1085     ColumnSelection colSel = viewport.getColumnSelection();
1086     if (colSel.size() > 0)
1087     {
1088       addHistoryItem(new HistoryItem("Remove Right", viewport.alignment,
1089                                      HistoryItem.HIDE));
1090       int max = colSel.getMax();
1091       viewport.getAlignment().trimRight(max);
1092
1093       if (viewport.getSelectionGroup() != null)
1094       {
1095         viewport.getSelectionGroup().adjustForRemoveRight(max);
1096       }
1097
1098       Vector groups = viewport.alignment.getGroups();
1099       for (int i = 0; i < groups.size(); i++)
1100       {
1101         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
1102         if (!sg.adjustForRemoveRight(max))
1103         {
1104           viewport.alignment.deleteGroup(sg);
1105         }
1106       }
1107       viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
1108     }
1109
1110   }
1111
1112   public void removeGappedColumnMenuItem_actionPerformed()
1113   {
1114     HistoryItem edit;
1115     addHistoryItem(edit=new HistoryItem("Remove Gapped Columns",
1116                                    viewport.alignment,
1117                                    HistoryItem.HIDE));
1118
1119     //This is to maintain viewport position on first residue
1120     //of first sequence
1121     SequenceI seq = viewport.alignment.getSequenceAt(0);
1122     int startRes = seq.findPosition(viewport.startRes);
1123
1124     viewport.getAlignment().removeGaps();
1125
1126     viewport.setStartRes(seq.findIndex(startRes)-1);
1127
1128     viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
1129   }
1130
1131   public void removeAllGapsMenuItem_actionPerformed()
1132   {
1133     // TODO: hidden regions should not be touched by removeAllGaps - a minimal number of gaps will remain in alignment segments containing uneven length subsequences
1134     // TODO: columnSelection.compensateforedits should be called (and passed to history item)
1135     HistoryItem editgaps;
1136     addHistoryItem(editgaps=new HistoryItem("Remove Gaps", viewport.alignment,
1137                                    HistoryItem.HIDE));
1138
1139     //This is to maintain viewport position on first residue
1140     //of first sequence
1141     SequenceI seq = viewport.alignment.getSequenceAt(0);
1142     int startRes = seq.findPosition(viewport.startRes);
1143
1144     SequenceI current;
1145     Vector seqs=null;
1146
1147     int start=0, end = viewport.alignment.getWidth();
1148
1149     if (viewport.getSelectionGroup() != null
1150         && viewport.getSelectionGroup().getSequences(false) != null
1151         && viewport.getSelectionGroup().getSize(false)>0)
1152     {
1153       seqs = viewport.getSelectionGroup().getSequences(true);
1154       start = viewport.getSelectionGroup().getStartRes();
1155       end = viewport.getSelectionGroup().getEndRes()+1;
1156     }
1157     else
1158       seqs = viewport.alignment.getSequences();
1159
1160     /* Commented out regions below are partial implementation of todo above.
1161      * divide start,end into visible chunks, and for each:
1162      int diff=end-start+1;
1163      int diffmax=0;
1164      int dr[] = new int[seqs.size()];
1165      */
1166     for (int i = 0; i < seqs.size(); i++)
1167     {
1168       current = (SequenceI) seqs.elementAt(i);
1169       //dr[i]=
1170       current.removeGaps(start, end);
1171       /*if (d<diff) // can only shift
1172         diff=d;
1173       if (diffmax<d)
1174         diffmax=d;
1175         */
1176     }
1177     /* // after the end of each chunk -
1178      * if (diff>0) {
1179      // record shift for history.
1180       editgaps.addShift(start, diff);
1181       if (viewport.hasHiddenColumns && diffmax>diff) {
1182       // pad sequence
1183        StringBuffer gaps=new StringBuffer(diffmax);
1184        for (int i=0,j=diffmax-diff; i<j; i++)
1185        gaps.append(viewport.getGapCharacter());
1186        for (int i=0, j=seqs.size(); i<j; i++) {
1187        current = (SequenceI) seqs.elementAt(i);
1188        if (dr[i]-diff>0) {
1189        String sq = current.getSequence();
1190        current.setSequence(sq.substring(0, hcend-dr[i])+gaps.substring(0, dr[i]-diff)+sq.substring());
1191        }
1192        }
1193       }
1194       }*/
1195
1196     viewport.setStartRes(seq.findIndex(startRes)-1);
1197     viewport.firePropertyChange("alignment", null, viewport.getAlignment().getSequences());
1198   }
1199
1200   public void alignmentChanged()
1201   {
1202     viewport.alignment.padGaps();
1203     if(viewport.autocalculateConsensus)
1204     {
1205       viewport.updateConsensus();
1206       viewport.updateConservation();
1207     }
1208
1209     resetAllColourSchemes();
1210     if(alignPanel.overviewPanel!=null)
1211       alignPanel.overviewPanel.updateOverviewImage();
1212
1213     viewport.alignment.adjustSequenceAnnotations();
1214     alignPanel.repaint();
1215   }
1216
1217   void resetAllColourSchemes()
1218   {
1219     ColourSchemeI cs = viewport.globalColourScheme;
1220     if(cs!=null)
1221     {
1222       if (cs instanceof ClustalxColourScheme)
1223       {
1224         ( (ClustalxColourScheme) viewport.getGlobalColourScheme()).
1225             resetClustalX(viewport.alignment.getSequences(),
1226                           viewport.alignment.getWidth());
1227       }
1228
1229       cs.setConsensus(viewport.vconsensus);
1230       if (cs.conservationApplied())
1231       {
1232         Alignment al = (Alignment) viewport.alignment;
1233         Conservation c = new Conservation("All",
1234                                           ResidueProperties.propHash, 3,
1235                                           al.getSequences(), 0,
1236                                           al.getWidth() - 1);
1237         c.calculate();
1238         c.verdict(false, viewport.ConsPercGaps);
1239
1240         cs.setConservation(c);
1241       }
1242     }
1243
1244     int s, sSize = viewport.alignment.getGroups().size();
1245     for(s=0; s<sSize; s++)
1246     {
1247       SequenceGroup sg = (SequenceGroup)viewport.alignment.getGroups().elementAt(s);
1248       if(sg.cs!=null && sg.cs instanceof ClustalxColourScheme)
1249       {
1250         ((ClustalxColourScheme)sg.cs).resetClustalX(
1251             sg.getSequences(true), sg.getWidth());
1252       }
1253       sg.recalcConservation();
1254     }
1255   }
1256
1257
1258
1259   public void findMenuItem_actionPerformed()
1260   {
1261     new Finder(alignPanel);
1262   }
1263
1264   public void font_actionPerformed()
1265   {
1266     new FontChooser(alignPanel);
1267   }
1268
1269
1270   public void seqLimits_itemStateChanged()
1271   {
1272     viewport.setShowJVSuffix(seqLimits.getState());
1273     alignPanel.fontChanged();
1274     alignPanel.repaint();
1275   }
1276
1277
1278   protected void colourTextMenuItem_actionPerformed()
1279   {
1280     viewport.setColourText(colourTextMenuItem.getState());
1281     alignPanel.repaint();
1282   }
1283
1284   protected void wrapMenuItem_actionPerformed()
1285   {
1286     viewport.setWrapAlignment(wrapMenuItem.getState());
1287     alignPanel.setWrapAlignment(wrapMenuItem.getState());
1288     scaleAbove.setEnabled(wrapMenuItem.getState());
1289     scaleLeft.setEnabled(wrapMenuItem.getState());
1290     scaleRight.setEnabled(wrapMenuItem.getState());
1291     alignPanel.repaint();
1292   }
1293
1294
1295   protected void scaleAbove_actionPerformed()
1296   {
1297     viewport.setScaleAboveWrapped(scaleAbove.getState());
1298     alignPanel.repaint();
1299   }
1300
1301   protected void scaleLeft_actionPerformed()
1302   {
1303     viewport.setScaleLeftWrapped(scaleLeft.getState());
1304     alignPanel.repaint();
1305   }
1306
1307   protected void scaleRight_actionPerformed()
1308   {
1309     viewport.setScaleRightWrapped(scaleRight.getState());
1310     alignPanel.repaint();
1311   }
1312
1313   public void viewBoxesMenuItem_actionPerformed()
1314   {
1315     viewport.setShowBoxes(viewBoxesMenuItem.getState());
1316     alignPanel.repaint();
1317   }
1318
1319   public void viewTextMenuItem_actionPerformed()
1320   {
1321     viewport.setShowText(viewTextMenuItem.getState());
1322     alignPanel.repaint();
1323   }
1324
1325   protected void renderGapsMenuItem_actionPerformed()
1326   {
1327     viewport.setRenderGaps(renderGapsMenuItem.getState());
1328     alignPanel.repaint();
1329   }
1330
1331   public void annotationPanelMenuItem_actionPerformed()
1332   {
1333     viewport.setShowAnnotation(annotationPanelMenuItem.getState());
1334     alignPanel.setAnnotationVisible(annotationPanelMenuItem.getState());
1335   }
1336
1337   public void featureSettings_actionPerformed()
1338   {
1339     new FeatureSettings(viewport, alignPanel);
1340   }
1341
1342   public void overviewMenuItem_actionPerformed()
1343   {
1344     if (alignPanel.overviewPanel != null)
1345     {
1346       return;
1347     }
1348
1349     Frame frame = new Frame();
1350     OverviewPanel overview = new OverviewPanel(alignPanel);
1351     frame.add(overview);
1352     // +50 must allow for applet frame window
1353     jalview.bin.JalviewLite.addFrame(frame, "Overview " + this.getTitle(),
1354                                      overview.preferredSize().width,
1355                                      overview.preferredSize().height + 50);
1356
1357     frame.pack();
1358     frame.addWindowListener(new WindowAdapter()
1359     {
1360       public void windowClosing(WindowEvent e)
1361       {
1362         alignPanel.setOverviewPanel(null);
1363       };
1364     });
1365
1366     alignPanel.setOverviewPanel(overview);
1367
1368   }
1369
1370   protected void noColourmenuItem_actionPerformed()
1371   {
1372     changeColour(null);
1373   }
1374
1375   public void clustalColour_actionPerformed()
1376   {
1377     abovePIDThreshold.setState(false);
1378     changeColour(new ClustalxColourScheme(viewport.alignment.getSequences(),
1379                                           viewport.alignment.getWidth()));
1380   }
1381
1382   public void zappoColour_actionPerformed()
1383   {
1384     changeColour(new ZappoColourScheme());
1385   }
1386
1387   public void taylorColour_actionPerformed()
1388   {
1389     changeColour(new TaylorColourScheme());
1390   }
1391
1392   public void hydrophobicityColour_actionPerformed()
1393   {
1394     changeColour(new HydrophobicColourScheme());
1395   }
1396
1397   public void helixColour_actionPerformed()
1398   {
1399     changeColour(new HelixColourScheme());
1400   }
1401
1402   public void strandColour_actionPerformed()
1403   {
1404     changeColour(new StrandColourScheme());
1405   }
1406
1407   public void turnColour_actionPerformed()
1408   {
1409     changeColour(new TurnColourScheme());
1410   }
1411
1412   public void buriedColour_actionPerformed()
1413   {
1414     changeColour(new BuriedColourScheme());
1415   }
1416
1417   public void nucleotideColour_actionPerformed()
1418   {
1419     changeColour(new NucleotideColourScheme());
1420   }
1421
1422   protected void applyToAllGroups_actionPerformed()
1423   {
1424     viewport.setColourAppliesToAllGroups(applyToAllGroups.getState());
1425   }
1426
1427   void changeColour(ColourSchemeI cs)
1428   {
1429     int threshold = 0;
1430
1431     if(cs!=null)
1432     {
1433       if (viewport.getAbovePIDThreshold())
1434       {
1435         threshold = SliderPanel.setPIDSliderSource(alignPanel, cs, "Background");
1436
1437         cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
1438
1439         viewport.setGlobalColourScheme(cs);
1440       }
1441       else
1442       {
1443         cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
1444       }
1445
1446       if (viewport.getConservationSelected())
1447       {
1448
1449         Alignment al = (Alignment) viewport.alignment;
1450         Conservation c = new Conservation("All",
1451                                           ResidueProperties.propHash, 3,
1452                                           al.getSequences(), 0,
1453                                           al.getWidth() - 1);
1454
1455         c.calculate();
1456         c.verdict(false, viewport.ConsPercGaps);
1457
1458         cs.setConservation(c);
1459
1460         cs.setConservationInc(SliderPanel.setConservationSlider(alignPanel, cs,
1461             "Background"));
1462
1463       }
1464       else
1465       {
1466         cs.setConservation(null);
1467       }
1468
1469       cs.setConsensus(viewport.vconsensus);
1470
1471     }
1472     viewport.setGlobalColourScheme(cs);
1473
1474     if (viewport.getColourAppliesToAllGroups())
1475     {
1476       Vector groups = viewport.alignment.getGroups();
1477       for (int i = 0; i < groups.size(); i++)
1478       {
1479         SequenceGroup sg = (SequenceGroup) groups.elementAt(i);
1480
1481         if(cs==null)
1482         {
1483           sg.cs = null;
1484           continue;
1485         }
1486         if (cs instanceof ClustalxColourScheme)
1487         {
1488           sg.cs = new ClustalxColourScheme(sg.getSequences(true), sg.getWidth());
1489         }
1490         else
1491         {
1492           try
1493           {
1494             sg.cs = (ColourSchemeI) cs.getClass().newInstance();
1495           }
1496           catch (Exception ex)
1497           {
1498             ex.printStackTrace();
1499             sg.cs = cs;
1500           }
1501         }
1502
1503         if (viewport.getAbovePIDThreshold()
1504             || cs instanceof PIDColourScheme
1505             || cs instanceof Blosum62ColourScheme)
1506         {
1507           sg.cs.setThreshold(threshold, viewport.getIgnoreGapsConsensus());
1508           sg.cs.setConsensus(AAFrequency.calculate(sg.getSequences(true), 0, sg.getWidth()));
1509         }
1510         else
1511           sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
1512
1513         if (viewport.getConservationSelected())
1514         {
1515           Conservation c = new Conservation("Group",
1516                                             ResidueProperties.propHash, 3,
1517                                             sg.getSequences(true), 0,
1518                                             viewport.alignment.getWidth() - 1);
1519           c.calculate();
1520           c.verdict(false, viewport.ConsPercGaps);
1521           sg.cs.setConservation(c);
1522         }
1523         else
1524         {
1525           sg.cs.setConservation(null);
1526           sg.cs.setThreshold(0, viewport.getIgnoreGapsConsensus());
1527         }
1528
1529       }
1530     }
1531
1532
1533     if (alignPanel.getOverviewPanel() != null)
1534     {
1535       alignPanel.getOverviewPanel().updateOverviewImage();
1536     }
1537
1538     alignPanel.repaint();
1539   }
1540
1541
1542
1543   protected void modifyPID_actionPerformed()
1544   {
1545     if (viewport.getAbovePIDThreshold() && viewport.globalColourScheme!=null)
1546     {
1547       SliderPanel.setPIDSliderSource(alignPanel, viewport.getGlobalColourScheme(),
1548                                      "Background");
1549       SliderPanel.showPIDSlider();
1550     }
1551   }
1552
1553   protected void modifyConservation_actionPerformed()
1554   {
1555     if (viewport.getConservationSelected() && viewport.globalColourScheme!=null)
1556     {
1557       SliderPanel.setConservationSlider(alignPanel, viewport.globalColourScheme,
1558                                         "Background");
1559       SliderPanel.showConservationSlider();
1560     }
1561   }
1562
1563   protected void conservationMenuItem_actionPerformed()
1564   {
1565     viewport.setConservationSelected(conservationMenuItem.getState());
1566
1567     viewport.setAbovePIDThreshold(false);
1568     abovePIDThreshold.setState(false);
1569
1570     changeColour(viewport.getGlobalColourScheme());
1571
1572     modifyConservation_actionPerformed();
1573   }
1574
1575   public void abovePIDThreshold_actionPerformed()
1576   {
1577     viewport.setAbovePIDThreshold(abovePIDThreshold.getState());
1578
1579     conservationMenuItem.setState(false);
1580     viewport.setConservationSelected(false);
1581
1582     changeColour(viewport.getGlobalColourScheme());
1583
1584     modifyPID_actionPerformed();
1585   }
1586
1587   public void userDefinedColour_actionPerformed()
1588   {
1589     new UserDefinedColours(alignPanel, null);
1590   }
1591
1592   public void PIDColour_actionPerformed()
1593   {
1594     changeColour(new PIDColourScheme());
1595   }
1596
1597   public void BLOSUM62Colour_actionPerformed()
1598   {
1599     changeColour(new Blosum62ColourScheme());
1600   }
1601
1602   public void sortPairwiseMenuItem_actionPerformed()
1603   {
1604     addHistoryItem(new HistoryItem("Pairwise Sort", viewport.alignment,
1605                                    HistoryItem.SORT));
1606     AlignmentSorter.sortByPID(viewport.getAlignment(),
1607                               viewport.getAlignment().getSequenceAt(0));
1608     alignPanel.repaint();
1609   }
1610
1611   public void sortIDMenuItem_actionPerformed()
1612   {
1613     addHistoryItem(new HistoryItem("ID Sort", viewport.alignment,
1614                                    HistoryItem.SORT));
1615     AlignmentSorter.sortByID(viewport.getAlignment());
1616     alignPanel.repaint();
1617   }
1618
1619   public void sortGroupMenuItem_actionPerformed()
1620   {
1621     addHistoryItem(new HistoryItem("Group Sort", viewport.alignment,
1622                                    HistoryItem.SORT));
1623     AlignmentSorter.sortByGroup(viewport.getAlignment());
1624     alignPanel.repaint();
1625
1626   }
1627
1628   public void removeRedundancyMenuItem_actionPerformed()
1629   {
1630      new RedundancyPanel(alignPanel);
1631   }
1632
1633   public void pairwiseAlignmentMenuItem_actionPerformed()
1634   {
1635     if (viewport.getSelectionGroup()!=null
1636         && viewport.getSelectionGroup().getSize(false) > 1)
1637     {
1638       Frame frame = new Frame();
1639       frame.add(new PairwiseAlignPanel(alignPanel));
1640       jalview.bin.JalviewLite.addFrame(frame, "Pairwise Alignment", 600, 500);
1641     }
1642   }
1643
1644   public void PCAMenuItem_actionPerformed()
1645   {
1646     //are the sequences aligned?
1647     if (!viewport.alignment.isAligned())
1648     {
1649       SequenceI current;
1650       int Width = viewport.getAlignment().getWidth();
1651
1652       for (int i = 0; i < viewport.getAlignment().getSequences().size();
1653            i++)
1654       {
1655         current = viewport.getAlignment().getSequenceAt(i);
1656
1657         if (current.getLength() < Width)
1658         {
1659           current.insertCharAt(Width - 1, viewport.getGapCharacter());
1660         }
1661       }
1662       alignPanel.repaint();
1663     }
1664
1665     if ( (viewport.getSelectionGroup() != null &&
1666           viewport.getSelectionGroup().getSize(false) < 4 &&
1667           viewport.getSelectionGroup().getSize(false) > 0)
1668         || viewport.getAlignment().getHeight() < 4)
1669     {
1670       return;
1671     }
1672
1673     try
1674     {
1675       new PCAPanel(viewport);
1676     }
1677     catch (java.lang.OutOfMemoryError ex)
1678     {
1679     }
1680
1681   }
1682
1683   public void averageDistanceTreeMenuItem_actionPerformed()
1684   {
1685     NewTreePanel("AV", "PID", "Average distance tree using PID");
1686   }
1687
1688   public void neighbourTreeMenuItem_actionPerformed()
1689   {
1690     NewTreePanel("NJ", "PID", "Neighbour joining tree using PID");
1691   }
1692
1693   protected void njTreeBlosumMenuItem_actionPerformed()
1694   {
1695     NewTreePanel("NJ", "BL", "Neighbour joining tree using BLOSUM62");
1696   }
1697
1698   protected void avTreeBlosumMenuItem_actionPerformed()
1699   {
1700     NewTreePanel("AV", "BL", "Average distance tree using BLOSUM62PID");
1701   }
1702
1703   void NewTreePanel(String type, String pwType, String title)
1704   {
1705     //are the sequences aligned?
1706     if (!viewport.alignment.isAligned())
1707     {
1708       SequenceI current;
1709       int Width = viewport.getAlignment().getWidth();
1710
1711       for (int i = 0; i < viewport.getAlignment().getSequences().size();
1712            i++)
1713       {
1714         current = viewport.getAlignment().getSequenceAt(i);
1715
1716         if (current.getLength() < Width)
1717         {
1718           current.insertCharAt(Width - 1, viewport.getGapCharacter());
1719         }
1720       }
1721       alignPanel.repaint();
1722
1723     }
1724
1725     if ( (viewport.getSelectionGroup() != null &&
1726           viewport.getSelectionGroup().getSize(false) > 1)
1727       || (viewport.getSelectionGroup() == null
1728           && viewport.alignment.getHeight() > 1))
1729     {
1730       final TreePanel tp = new TreePanel(viewport,
1731                                          type,
1732                                          pwType);
1733
1734       addTreeMenuItem(tp, title);
1735
1736       jalview.bin.JalviewLite.addFrame(tp, title, 600, 500);
1737     }
1738   }
1739
1740   void loadTree_actionPerformed()
1741   {
1742       CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this);
1743       cap.setText("Paste your Newick tree file here.");
1744       cap.treeImport = true;
1745       Frame frame = new Frame();
1746       frame.add(cap);
1747       jalview.bin.JalviewLite.addFrame(frame, "Paste Newick file ", 400, 300);
1748   }
1749
1750   public void loadTree(jalview.io.NewickFile tree, String treeFile)
1751   {
1752     TreePanel tp = new TreePanel(viewport,
1753                                  treeFile,
1754                                  "From File - ",
1755                                  tree);
1756     jalview.bin.JalviewLite.addFrame(tp, treeFile, 600, 500);
1757     addTreeMenuItem(tp, treeFile);
1758   }
1759
1760   void addTreeMenuItem(final TreePanel treePanel, String title)
1761   {
1762     final MenuItem item = new MenuItem(title);
1763     sortByTreeMenu.add(item);
1764     item.addActionListener(new java.awt.event.ActionListener()
1765     {
1766       public void actionPerformed(ActionEvent evt)
1767       {
1768         addHistoryItem(new HistoryItem("Sort", viewport.alignment,
1769                                        HistoryItem.SORT));
1770         AlignmentSorter.sortByTree(viewport.getAlignment(), treePanel.getTree());
1771         alignPanel.repaint();
1772       }
1773     });
1774
1775     treePanel.addWindowListener(new WindowAdapter()
1776     {
1777       public void windowClosing(WindowEvent e)
1778       {
1779         sortByTreeMenu.remove(item);
1780       };
1781     });
1782   }
1783
1784   protected void documentation_actionPerformed()
1785   {
1786     showURL("http://www.jalview.org/help.html", "HELP");
1787   }
1788
1789   protected void about_actionPerformed()
1790   {
1791
1792     class AboutPanel extends Canvas
1793     {
1794       String version;
1795       public AboutPanel(String version)
1796       { this.version = version; }
1797
1798       public void paint(Graphics g)
1799       {
1800         g.setColor(Color.white);
1801         g.fillRect(0, 0, getSize().width, getSize().height);
1802         g.setFont(new Font("Helvetica", Font.PLAIN, 12));
1803         FontMetrics fm = g.getFontMetrics();
1804         int fh = fm.getHeight();
1805         int y = 5, x = 7;
1806         g.setColor(Color.black);
1807         g.setFont(new Font("Helvetica", Font.BOLD, 14));
1808         g.drawString("Jalview - Release "+version, 200, y += fh);
1809         g.setFont(new Font("Helvetica", Font.PLAIN, 12));
1810         g.drawString("Authors:  Michele Clamp, James Cuff, Steve Searle, Andrew Waterhouse, Jim Procter & Geoff Barton.",
1811                      x, y += fh * 2);
1812         g.drawString("Current development managed by Andrew Waterhouse; Barton Group, University of Dundee.",
1813                      x, y += fh);
1814         g.drawString(
1815             "For any issues relating to Jalview, email help@jalview.org", x,
1816             y += fh);
1817         g.drawString("If  you use JalView, please cite:", x, y += fh + 8);
1818         g.drawString("\"Clamp, M., Cuff, J., Searle, S. M. and Barton, G. J. (2004), The Jalview Java Alignment Editor\"",
1819                      x, y += fh);
1820         g.drawString("Bioinformatics,  2004 20;426-7.", x, y += fh);
1821       }
1822     }
1823
1824     String version = "test";
1825     java.net.URL url = getClass().getResource("/.build_properties");
1826     if (url != null)
1827     {
1828       try
1829       {
1830         BufferedReader reader = new BufferedReader(new InputStreamReader(
1831             url.openStream()));
1832         String line;
1833         while ( (line = reader.readLine()) != null)
1834         {
1835           if (line.indexOf("VERSION") > -1)
1836           {
1837             version = line.substring(line.indexOf("=") + 1);
1838           }
1839         }
1840       }
1841       catch (Exception ex)
1842       {
1843         ex.printStackTrace();
1844       }
1845     }
1846
1847
1848     Frame frame = new Frame();
1849     frame.add(new AboutPanel(version));
1850     jalview.bin.JalviewLite.addFrame(frame, "Jalview", 580, 200);
1851
1852   }
1853
1854   public void showURL(String url, String target)
1855   {
1856     if (viewport.applet == null)
1857     {
1858       System.out.println("Not running as applet - no browser available.");
1859     }
1860     else
1861     {
1862       try
1863       {
1864         System.out.println("Show url: "+url);
1865         viewport.applet.getAppletContext().showDocument(new java.net.URL(url),
1866                                                target);
1867       }
1868       catch (Exception ex)
1869       {
1870         ex.printStackTrace();
1871       }
1872     }
1873   }
1874
1875
1876   //////////////////////////////////////////////////////////////////////////////////
1877   //JBuilder Graphics here
1878
1879     protected MenuBar alignFrameMenuBar = new MenuBar();
1880     protected Menu fileMenu = new Menu("File");
1881     protected MenuItem loadApplication = new MenuItem("View in Full Application");
1882     protected MenuItem loadTree = new MenuItem("Load Associated Tree");
1883     protected MenuItem closeMenuItem = new MenuItem("Close");
1884     protected Menu editMenu = new Menu("Edit");
1885     protected Menu viewMenu = new Menu("View");
1886     protected Menu colourMenu = new Menu("Colour");
1887     protected Menu calculateMenu = new Menu("Calculate");
1888     protected MenuItem selectAllSequenceMenuItem = new MenuItem("Select all");
1889     protected MenuItem deselectAllSequenceMenuItem = new MenuItem("Deselect All");
1890     protected MenuItem invertSequenceMenuItem = new MenuItem("Invert Selection");
1891     protected MenuItem remove2LeftMenuItem = new MenuItem();
1892     protected MenuItem remove2RightMenuItem = new MenuItem();
1893     protected MenuItem removeGappedColumnMenuItem = new MenuItem();
1894     protected MenuItem removeAllGapsMenuItem = new MenuItem();
1895     protected CheckboxMenuItem viewBoxesMenuItem = new CheckboxMenuItem();
1896     protected CheckboxMenuItem viewTextMenuItem = new CheckboxMenuItem();
1897     protected MenuItem sortPairwiseMenuItem = new MenuItem();
1898     protected MenuItem sortIDMenuItem = new MenuItem();
1899     protected MenuItem sortGroupMenuItem = new MenuItem();
1900     protected MenuItem removeRedundancyMenuItem = new MenuItem();
1901     protected MenuItem pairwiseAlignmentMenuItem = new MenuItem();
1902     protected MenuItem PCAMenuItem = new MenuItem();
1903     protected MenuItem averageDistanceTreeMenuItem = new MenuItem();
1904     protected MenuItem neighbourTreeMenuItem = new MenuItem();
1905     BorderLayout borderLayout1 = new BorderLayout();
1906     public Label statusBar = new Label();
1907     protected Menu outputTextboxMenu = new Menu();
1908     protected MenuItem clustalColour = new MenuItem();
1909     protected MenuItem zappoColour = new MenuItem();
1910     protected MenuItem taylorColour = new MenuItem();
1911     protected MenuItem hydrophobicityColour = new MenuItem();
1912     protected MenuItem helixColour = new MenuItem();
1913     protected MenuItem strandColour = new MenuItem();
1914     protected MenuItem turnColour = new MenuItem();
1915     protected MenuItem buriedColour = new MenuItem();
1916     protected MenuItem userDefinedColour = new MenuItem();
1917     protected MenuItem PIDColour = new MenuItem();
1918     protected MenuItem BLOSUM62Colour = new MenuItem();
1919     MenuItem njTreeBlosumMenuItem = new MenuItem();
1920     MenuItem avDistanceTreeBlosumMenuItem = new MenuItem();
1921     protected CheckboxMenuItem annotationPanelMenuItem = new CheckboxMenuItem();
1922     protected CheckboxMenuItem colourTextMenuItem = new CheckboxMenuItem();
1923     MenuItem overviewMenuItem = new MenuItem();
1924     protected MenuItem undoMenuItem = new MenuItem();
1925     protected MenuItem redoMenuItem = new MenuItem();
1926     protected CheckboxMenuItem conservationMenuItem = new CheckboxMenuItem();
1927     MenuItem noColourmenuItem = new MenuItem();
1928     protected CheckboxMenuItem wrapMenuItem = new CheckboxMenuItem();
1929     protected CheckboxMenuItem renderGapsMenuItem = new CheckboxMenuItem();
1930     MenuItem findMenuItem = new MenuItem();
1931     Menu searchMenu = new Menu();
1932     protected CheckboxMenuItem abovePIDThreshold = new CheckboxMenuItem();
1933     protected MenuItem nucleotideColour = new MenuItem();
1934     MenuItem deleteGroups = new MenuItem();
1935     MenuItem delete = new MenuItem();
1936     MenuItem copy = new MenuItem();
1937     MenuItem cut = new MenuItem();
1938     Menu pasteMenu = new Menu();
1939     MenuItem pasteNew = new MenuItem();
1940     MenuItem pasteThis = new MenuItem();
1941     protected CheckboxMenuItem applyToAllGroups = new CheckboxMenuItem();
1942     protected MenuItem font = new MenuItem();
1943     protected CheckboxMenuItem scaleAbove = new CheckboxMenuItem();
1944     protected CheckboxMenuItem scaleLeft = new CheckboxMenuItem();
1945     protected CheckboxMenuItem scaleRight = new CheckboxMenuItem();
1946     MenuItem modifyPID = new MenuItem();
1947     MenuItem modifyConservation = new MenuItem();
1948     protected CheckboxMenuItem autoCalculate
1949         = new CheckboxMenuItem("Autocalculate Consensus", true);
1950     protected Menu sortByTreeMenu = new Menu();
1951     Menu sort = new Menu();
1952     Menu calculate = new Menu();
1953     MenuItem inputText = new MenuItem();
1954     Menu helpMenu = new Menu();
1955     MenuItem documentation = new MenuItem();
1956     MenuItem about = new MenuItem();
1957     protected CheckboxMenuItem seqLimits = new CheckboxMenuItem();
1958   Panel embeddedMenu;
1959   Label embeddedEdit;
1960   Label embeddedSearch;
1961   Label embeddedView;
1962   Label embeddedColour;
1963   Label embeddedFile;
1964   Label embeddedHelp;
1965   Label embeddedCalculate;
1966   FlowLayout flowLayout1;
1967
1968   private void jbInit() throws Exception {
1969
1970       setMenuBar(alignFrameMenuBar);
1971
1972       MenuItem item;
1973
1974       // dynamically fill save as menu with available formats
1975       for (int i = 0; i < jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS.length; i++)
1976       {
1977
1978         item = new MenuItem( jalview.io.AppletFormatAdapter.WRITEABLE_FORMATS[i]);
1979
1980         item.addActionListener(new java.awt.event.ActionListener()
1981         {
1982           public void actionPerformed(ActionEvent e)
1983           {
1984             outputText_actionPerformed(e);
1985           }
1986         });
1987
1988         outputTextboxMenu.add(item);
1989       }
1990         closeMenuItem.addActionListener(this);
1991         loadApplication.addActionListener(this);
1992
1993         loadTree.addActionListener(this);
1994         selectAllSequenceMenuItem.addActionListener(this);
1995         deselectAllSequenceMenuItem.addActionListener(this);
1996         invertSequenceMenuItem.addActionListener(this);
1997         remove2LeftMenuItem.setLabel("Remove Left");
1998         remove2LeftMenuItem.addActionListener(this);
1999         remove2RightMenuItem.setLabel("Remove Right");
2000         remove2RightMenuItem.addActionListener(this);
2001         removeGappedColumnMenuItem.setLabel("Remove Empty Columns");
2002         removeGappedColumnMenuItem.addActionListener(this);
2003         removeAllGapsMenuItem.setLabel("Remove All Gaps");
2004         removeAllGapsMenuItem.addActionListener(this);
2005         viewBoxesMenuItem.setLabel("Boxes");
2006         viewBoxesMenuItem.setState(true);
2007         viewBoxesMenuItem.addItemListener(this);
2008         viewTextMenuItem.setLabel("Text");
2009         viewTextMenuItem.setState(true);
2010         viewTextMenuItem.addItemListener(this);
2011         sortPairwiseMenuItem.setLabel("by Pairwise Identity");
2012         sortPairwiseMenuItem.addActionListener(this);
2013         sortIDMenuItem.setLabel("by ID");
2014         sortIDMenuItem.addActionListener(this);
2015         sortGroupMenuItem.setLabel("by Group");
2016         sortGroupMenuItem.addActionListener(this);
2017         removeRedundancyMenuItem.setLabel("Remove Redundancy...");
2018         removeRedundancyMenuItem.addActionListener(this);
2019         pairwiseAlignmentMenuItem.setLabel("Pairwise Alignments...");
2020         pairwiseAlignmentMenuItem.addActionListener(this);
2021         PCAMenuItem.setLabel("Principal Component Analysis");
2022         PCAMenuItem.addActionListener(this);
2023         averageDistanceTreeMenuItem.setLabel(
2024             "Average Distance Using % Identity");
2025         averageDistanceTreeMenuItem.addActionListener(this);
2026         neighbourTreeMenuItem.setLabel("Neighbour Joining Using % Identity");
2027         neighbourTreeMenuItem.addActionListener(this);
2028         alignFrameMenuBar.setFont(new java.awt.Font("Verdana", 0, 11));
2029         statusBar.setBackground(Color.white);
2030         statusBar.setFont(new java.awt.Font("Verdana", 0, 11));
2031         statusBar.setText("Status bar");
2032         outputTextboxMenu.setLabel("Output to Textbox");
2033         clustalColour.setLabel("Clustalx");
2034
2035         clustalColour.addActionListener(this);
2036         zappoColour.setLabel("Zappo");
2037         zappoColour.addActionListener(this);
2038         taylorColour.setLabel("Taylor");
2039         taylorColour.addActionListener(this);
2040         hydrophobicityColour.setLabel("Hydrophobicity");
2041         hydrophobicityColour.addActionListener(this);
2042         helixColour.setLabel("Helix Propensity");
2043         helixColour.addActionListener(this);
2044         strandColour.setLabel("Strand Propensity");
2045         strandColour.addActionListener(this);
2046         turnColour.setLabel("Turn Propensity");
2047         turnColour.addActionListener(this);
2048         buriedColour.setLabel("Buried Index");
2049         buriedColour.addActionListener(this);
2050         userDefinedColour.setLabel("User Defined...");
2051         userDefinedColour.addActionListener(this);
2052         PIDColour.setLabel("Percentage Identity");
2053         PIDColour.addActionListener(this);
2054         BLOSUM62Colour.setLabel("BLOSUM62 Score");
2055         BLOSUM62Colour.addActionListener(this);
2056         avDistanceTreeBlosumMenuItem.setLabel(
2057             "Average Distance Using BLOSUM62");
2058         avDistanceTreeBlosumMenuItem.addActionListener(this);
2059         njTreeBlosumMenuItem.setLabel("Neighbour Joining Using BLOSUM62");
2060         njTreeBlosumMenuItem.addActionListener(this);
2061         annotationPanelMenuItem.setLabel("Show Annotations");
2062         annotationPanelMenuItem.addItemListener(this);
2063         colourTextMenuItem.setLabel("Colour Text");
2064         colourTextMenuItem.addItemListener(this);
2065         overviewMenuItem.setLabel("Overview Window");
2066         overviewMenuItem.addActionListener(this);
2067         undoMenuItem.setEnabled(false);
2068         undoMenuItem.setLabel("Undo");
2069         undoMenuItem.addActionListener(this);
2070         redoMenuItem.setEnabled(false);
2071         redoMenuItem.setLabel("Redo");
2072         redoMenuItem.addActionListener(this);
2073         conservationMenuItem.setLabel("by Conservation");
2074         conservationMenuItem.addItemListener(this);
2075         noColourmenuItem.setLabel("None");
2076         noColourmenuItem.addActionListener(this);
2077         wrapMenuItem.setLabel("Wrap");
2078         wrapMenuItem.addItemListener(this);
2079         renderGapsMenuItem.setLabel("Show Gaps");
2080         renderGapsMenuItem.setState(true);
2081         renderGapsMenuItem.addItemListener(this);
2082         findMenuItem.setLabel("Find...");
2083         findMenuItem.addActionListener(this);
2084         searchMenu.setLabel("Search");
2085
2086         abovePIDThreshold.setLabel("Above Identity Threshold");
2087         abovePIDThreshold.addItemListener(this);
2088         nucleotideColour.setLabel("Nucleotide");
2089         nucleotideColour.addActionListener(this);
2090         deleteGroups.setLabel("Undefine Groups");
2091         deleteGroups.addActionListener(this);
2092         copy.setLabel("Copy");
2093         copy.addActionListener(this);
2094         cut.setLabel("Cut");
2095         cut.addActionListener(this);
2096         delete.setLabel("Delete");
2097         delete.addActionListener(this);
2098         pasteMenu.setLabel("Paste");
2099         pasteNew.setLabel("To New Alignment");
2100         pasteNew.addActionListener(this);
2101         pasteThis.setLabel("Add To This Alignment");
2102         pasteThis.addActionListener(this);
2103         applyToAllGroups.setLabel("Apply Colour To All Groups");
2104         applyToAllGroups.setState(true);
2105         applyToAllGroups.addItemListener(this);
2106         font.setLabel("Font...");
2107         font.addActionListener(this);
2108         scaleAbove.setLabel("Scale Above");
2109         scaleAbove.setState(true);
2110         scaleAbove.setEnabled(false);
2111         scaleAbove.addItemListener(this);
2112         scaleLeft.setEnabled(false);
2113         scaleLeft.setState(true);
2114         scaleLeft.setLabel("Scale Left");
2115         scaleLeft.addItemListener(this);
2116         scaleRight.setEnabled(false);
2117         scaleRight.setState(true);
2118         scaleRight.setLabel("Scale Right");
2119         scaleRight.addItemListener(this);
2120         modifyPID.setLabel("Modify Identity Threshold...");
2121         modifyPID.addActionListener(this);
2122         modifyConservation.setLabel("Modify Conservation Threshold...");
2123         modifyConservation.addActionListener(this);
2124         sortByTreeMenu.setLabel("By Tree Order");
2125         sort.setLabel("Sort");
2126         calculate.setLabel("Calculate Tree");
2127         autoCalculate.addItemListener(this);
2128         inputText.setLabel("Input from textbox");
2129         inputText.addActionListener(this);
2130
2131         helpMenu.setLabel("Help");
2132         documentation.setLabel("Documentation");
2133         documentation.addActionListener(this);
2134
2135         about.setLabel("About...");
2136         about.addActionListener(this);
2137           seqLimits.setState(true);
2138     seqLimits.setLabel("Show Sequence Limits");
2139     seqLimits.addItemListener(this);
2140     featureSettings.setLabel("Feature Settings...");
2141     featureSettings.addActionListener(this);
2142     sequenceFeatures.setLabel("Sequence Features");
2143     sequenceFeatures.addItemListener(this);
2144     sequenceFeatures.setState(false);
2145     annotationColour.setLabel("by Annotation...");
2146     annotationColour.addActionListener(this);
2147     invertSequenceMenuItem.setLabel("Invert Sequence Selection");
2148     invertColSel.setLabel("Invert Column Selection");
2149     menu1.setLabel("Show");
2150     showColumns.setLabel("All Columns ");
2151     showSeqs.setLabel("All Sequences");
2152     menu2.setLabel("Hide");
2153     hideColumns.setLabel("Selected Columns");
2154     hideSequences.setLabel("Selected Sequences");
2155     invertColSel.addActionListener(this);
2156     showColumns.addActionListener(this);
2157     showSeqs.addActionListener(this);
2158     hideColumns.addActionListener(this);
2159     hideSequences.addActionListener(this);
2160
2161
2162     alignFrameMenuBar.add(fileMenu);
2163         alignFrameMenuBar.add(editMenu);
2164         alignFrameMenuBar.add(searchMenu);
2165         alignFrameMenuBar.add(viewMenu);
2166         alignFrameMenuBar.add(colourMenu);
2167         alignFrameMenuBar.add(calculateMenu);
2168         alignFrameMenuBar.add(helpMenu);
2169         fileMenu.add(inputText);
2170         fileMenu.add(outputTextboxMenu);
2171         if(jalviewServletURL!=null)
2172           fileMenu.add(loadApplication);
2173         fileMenu.addSeparator();
2174         fileMenu.add(loadTree);
2175         fileMenu.add(closeMenuItem);
2176         editMenu.add(undoMenuItem);
2177         editMenu.add(redoMenuItem);
2178         editMenu.add(cut);
2179         editMenu.add(copy);
2180         editMenu.add(pasteMenu);
2181         editMenu.add(delete);
2182         editMenu.addSeparator();
2183         editMenu.add(selectAllSequenceMenuItem);
2184         editMenu.add(deselectAllSequenceMenuItem);
2185         editMenu.add(invertSequenceMenuItem);
2186     editMenu.add(invertColSel);
2187     editMenu.add(deleteGroups);
2188         editMenu.addSeparator();
2189         editMenu.add(remove2LeftMenuItem);
2190         editMenu.add(remove2RightMenuItem);
2191         editMenu.add(removeGappedColumnMenuItem);
2192         editMenu.add(removeAllGapsMenuItem);
2193         editMenu.add(removeRedundancyMenuItem);
2194         searchMenu.add(findMenuItem);
2195         viewMenu.add(font);
2196         viewMenu.addSeparator();
2197     viewMenu.add(menu1);
2198     viewMenu.add(menu2);
2199     viewMenu.addSeparator();
2200     viewMenu.add(wrapMenuItem);
2201         viewMenu.add(scaleAbove);
2202         viewMenu.add(scaleLeft);
2203         viewMenu.add(scaleRight);
2204         viewMenu.addSeparator();
2205     viewMenu.add(seqLimits);
2206     viewMenu.add(viewBoxesMenuItem);
2207         viewMenu.add(viewTextMenuItem);
2208         viewMenu.add(colourTextMenuItem);
2209         viewMenu.add(renderGapsMenuItem);
2210         viewMenu.add(annotationPanelMenuItem);
2211     viewMenu.addSeparator();
2212         viewMenu.add(sequenceFeatures);
2213         viewMenu.add(featureSettings);
2214     viewMenu.addSeparator();
2215         viewMenu.add(overviewMenuItem);
2216         colourMenu.add(applyToAllGroups);
2217         colourMenu.addSeparator();
2218         colourMenu.add(noColourmenuItem);
2219         colourMenu.add(clustalColour);
2220         colourMenu.add(BLOSUM62Colour);
2221         colourMenu.add(PIDColour);
2222         colourMenu.add(zappoColour);
2223         colourMenu.add(taylorColour);
2224         colourMenu.add(hydrophobicityColour);
2225         colourMenu.add(helixColour);
2226         colourMenu.add(strandColour);
2227         colourMenu.add(turnColour);
2228         colourMenu.add(buriedColour);
2229         colourMenu.add(nucleotideColour);
2230         colourMenu.add(userDefinedColour);
2231         colourMenu.addSeparator();
2232         colourMenu.add(conservationMenuItem);
2233         colourMenu.add(modifyConservation);
2234         colourMenu.add(abovePIDThreshold);
2235         colourMenu.add(modifyPID);
2236     colourMenu.add(annotationColour);
2237     calculateMenu.add(sort);
2238         calculateMenu.add(calculate);
2239         calculateMenu.addSeparator();
2240         calculateMenu.add(pairwiseAlignmentMenuItem);
2241         calculateMenu.add(PCAMenuItem);
2242         calculateMenu.add(autoCalculate);
2243         this.add(statusBar, BorderLayout.SOUTH);
2244         pasteMenu.add(pasteNew);
2245         pasteMenu.add(pasteThis);
2246         sort.add(sortIDMenuItem);
2247         sort.add(sortByTreeMenu);
2248         sort.add(sortGroupMenuItem);
2249         sort.add(sortPairwiseMenuItem);
2250         calculate.add(averageDistanceTreeMenuItem);
2251         calculate.add(neighbourTreeMenuItem);
2252         calculate.add(avDistanceTreeBlosumMenuItem);
2253         calculate.add(njTreeBlosumMenuItem);
2254         helpMenu.add(documentation);
2255         helpMenu.add(about);
2256     menu1.add(showColumns);
2257     menu1.add(showSeqs);
2258     menu2.add(hideColumns);
2259     menu2.add(hideSequences);
2260   }
2261
2262   public void setEmbedded()
2263   {
2264
2265     embeddedMenu = new Panel();
2266     embeddedEdit = new Label();
2267     embeddedSearch = new Label();
2268     embeddedView = new Label();
2269     embeddedColour = new Label();
2270     embeddedFile = new Label();
2271     embeddedHelp = new Label();
2272     embeddedCalculate = new Label();
2273     flowLayout1 = new FlowLayout();
2274     embeddedMenu.setBackground(Color.lightGray);
2275     embeddedMenu.setLayout(flowLayout1);
2276     embeddedEdit.setText("Edit");
2277     embeddedEdit.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
2278     embeddedSearch.setText("Search");
2279     embeddedSearch.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
2280     embeddedView.setText("View");
2281     embeddedView.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
2282     embeddedColour.setText("Colour");
2283     embeddedColour.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
2284     embeddedFile.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
2285     embeddedFile.setText("File");
2286     embeddedHelp.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
2287     embeddedHelp.setText("Help");
2288     embeddedCalculate.setFont(new java.awt.Font("Arial", Font.PLAIN, 10));
2289     embeddedCalculate.setText("Calculate");
2290     embeddedMenu.add(embeddedFile);
2291     embeddedMenu.add(embeddedEdit);
2292     embeddedMenu.add(embeddedSearch);
2293     embeddedMenu.add(embeddedView);
2294     embeddedMenu.add(embeddedColour);
2295     embeddedMenu.add(embeddedCalculate);
2296     embeddedMenu.add(embeddedHelp);
2297     flowLayout1.setAlignment(FlowLayout.LEFT);
2298     flowLayout1.setHgap(2);
2299     flowLayout1.setVgap(0);
2300     embeddedFile.addMouseListener(this);
2301     embeddedEdit.addMouseListener(this);
2302     embeddedSearch.addMouseListener(this);
2303     embeddedView.addMouseListener(this);
2304     embeddedColour.addMouseListener(this);
2305     embeddedCalculate.addMouseListener(this);
2306     embeddedHelp.addMouseListener(this);
2307
2308    // setVisible(false);
2309     fileMenu.remove(closeMenuItem);
2310     fileMenu.remove(3); // Seperator
2311
2312     viewport.applet.setLayout(new BorderLayout());
2313     viewport.applet.add(embeddedMenu, BorderLayout.NORTH);
2314     viewport.applet.add(statusBar, BorderLayout.SOUTH);
2315    // viewport.applet.validate();
2316
2317     alignPanel.setSize(viewport.applet.size().width, viewport.applet.size().height
2318                        - embeddedMenu.HEIGHT - statusBar.HEIGHT);
2319
2320      viewport.applet.add(alignPanel, BorderLayout.CENTER);
2321      viewport.applet.validate();
2322
2323   }
2324
2325
2326
2327   PopupMenu filePopup, editPopup, searchPopup,
2328       viewPopup, colourPopup, calculatePopup, helpPopup;
2329   MenuItem featureSettings = new MenuItem();
2330   CheckboxMenuItem sequenceFeatures = new CheckboxMenuItem();
2331   MenuItem annotationColour = new MenuItem();
2332   MenuItem invertColSel = new MenuItem();
2333   Menu menu1 = new Menu();
2334   MenuItem showColumns = new MenuItem();
2335   MenuItem showSeqs = new MenuItem();
2336   Menu menu2 = new Menu();
2337   MenuItem hideColumns = new MenuItem();
2338   MenuItem hideSequences = new MenuItem();
2339
2340   public void mousePressed(MouseEvent evt)
2341   {
2342     PopupMenu popup = null;
2343     Label source = (Label)evt.getSource();
2344     if(source==embeddedFile)
2345     {
2346       popup = filePopup = genPopupMenu(filePopup, fileMenu);
2347     }
2348     else if(source==embeddedEdit)
2349     {
2350       popup = editPopup = genPopupMenu(editPopup, editMenu);
2351     }
2352     else if(source==embeddedSearch)
2353     {
2354       popup = searchPopup = genPopupMenu(searchPopup, searchMenu);
2355     }
2356     else if(source==embeddedView)
2357     {
2358       popup = viewPopup = genPopupMenu(viewPopup, viewMenu);
2359     }
2360     else if(source==embeddedColour)
2361     {
2362       popup = colourPopup = genPopupMenu(colourPopup, colourMenu);
2363     }
2364     else if(source==embeddedCalculate)
2365     {
2366       popup = calculatePopup = genPopupMenu(calculatePopup, calculateMenu);
2367     }
2368     else if(source==embeddedHelp)
2369     {
2370       popup = helpPopup = genPopupMenu(helpPopup, helpMenu);
2371     }
2372
2373     embeddedMenu.add(popup);
2374     popup.show(embeddedMenu,
2375                source.getBounds().x,
2376                source.getBounds().y + source.getBounds().getSize().height);
2377   }
2378
2379   PopupMenu genPopupMenu(PopupMenu popup, Menu original)
2380   {
2381     if(popup!=null)
2382     {
2383       return popup;
2384     }
2385     popup = new PopupMenu();
2386     int m, mSize = original.getItemCount();
2387     for(m=0; m<mSize; m++)
2388     {
2389       popup.add(original.getItem(m));
2390       mSize--;
2391       m--;
2392     }
2393
2394     return popup;
2395   }
2396   public void mouseClicked(MouseEvent evt)
2397   {}
2398   public void mouseReleased(MouseEvent evt)
2399   {}
2400   public void mouseEntered(MouseEvent evt)
2401   {}
2402   public void mouseExited(MouseEvent evt)
2403   {}
2404
2405 }
2406