1 /* 2 * Jalview - A Sequence Alignment Editor and Viewer (2.11.1.4) 3 * Copyright (C) 2021 The Jalview Authors 4 * 5 * This file is part of Jalview. 6 * 7 * Jalview is free software: you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation, either version 3 10 * of the License, or (at your option) any later version. 11 * 12 * Jalview is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty 14 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 15 * PURPOSE. See the GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with Jalview. If not, see <http://www.gnu.org/licenses/>. 19 * The Jalview Authors are detailed in the 'AUTHORS' file. 20 */ 21 package jalview.appletgui; 22 23 import jalview.analysis.AlignmentSorter; 24 import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder; 25 import jalview.analysis.TreeBuilder; 26 import jalview.analysis.scoremodels.PIDModel; 27 import jalview.analysis.scoremodels.ScoreModels; 28 import jalview.api.AlignViewControllerGuiI; 29 import jalview.api.AlignViewControllerI; 30 import jalview.api.AlignViewportI; 31 import jalview.api.FeatureColourI; 32 import jalview.api.FeatureRenderer; 33 import jalview.api.FeatureSettingsControllerI; 34 import jalview.api.SequenceStructureBinding; 35 import jalview.bin.JalviewLite; 36 import jalview.commands.CommandI; 37 import jalview.commands.EditCommand; 38 import jalview.commands.EditCommand.Action; 39 import jalview.commands.OrderCommand; 40 import jalview.commands.RemoveGapColCommand; 41 import jalview.commands.RemoveGapsCommand; 42 import jalview.commands.SlideSequencesCommand; 43 import jalview.commands.TrimRegionCommand; 44 import jalview.datamodel.Alignment; 45 import jalview.datamodel.AlignmentAnnotation; 46 import jalview.datamodel.AlignmentI; 47 import jalview.datamodel.AlignmentOrder; 48 import jalview.datamodel.ColumnSelection; 49 import jalview.datamodel.HiddenColumns; 50 import jalview.datamodel.PDBEntry; 51 import jalview.datamodel.Sequence; 52 import jalview.datamodel.SequenceGroup; 53 import jalview.datamodel.SequenceI; 54 import jalview.io.AnnotationFile; 55 import jalview.io.AppletFormatAdapter; 56 import jalview.io.DataSourceType; 57 import jalview.io.FeaturesFile; 58 import jalview.io.FileFormat; 59 import jalview.io.FileFormatI; 60 import jalview.io.FileFormats; 61 import jalview.io.TCoffeeScoreFile; 62 import jalview.schemes.Blosum62ColourScheme; 63 import jalview.schemes.BuriedColourScheme; 64 import jalview.schemes.ClustalxColourScheme; 65 import jalview.schemes.ColourSchemeI; 66 import jalview.schemes.HelixColourScheme; 67 import jalview.schemes.HydrophobicColourScheme; 68 import jalview.schemes.NucleotideColourScheme; 69 import jalview.schemes.PIDColourScheme; 70 import jalview.schemes.PurinePyrimidineColourScheme; 71 import jalview.schemes.RNAHelicesColour; 72 import jalview.schemes.StrandColourScheme; 73 import jalview.schemes.TCoffeeColourScheme; 74 import jalview.schemes.TaylorColourScheme; 75 import jalview.schemes.TurnColourScheme; 76 import jalview.schemes.ZappoColourScheme; 77 import jalview.structure.StructureSelectionManager; 78 import jalview.structures.models.AAStructureBindingModel; 79 import jalview.util.MappingUtils; 80 import jalview.util.MessageManager; 81 import jalview.viewmodel.AlignmentViewport; 82 import jalview.viewmodel.ViewportRanges; 83 84 import java.awt.BorderLayout; 85 import java.awt.Canvas; 86 import java.awt.CheckboxMenuItem; 87 import java.awt.Color; 88 import java.awt.FlowLayout; 89 import java.awt.Font; 90 import java.awt.FontMetrics; 91 import java.awt.Frame; 92 import java.awt.Graphics; 93 import java.awt.Label; 94 import java.awt.Menu; 95 import java.awt.MenuBar; 96 import java.awt.MenuItem; 97 import java.awt.Panel; 98 import java.awt.Rectangle; 99 import java.awt.event.ActionEvent; 100 import java.awt.event.ActionListener; 101 import java.awt.event.FocusEvent; 102 import java.awt.event.FocusListener; 103 import java.awt.event.ItemEvent; 104 import java.awt.event.ItemListener; 105 import java.awt.event.KeyEvent; 106 import java.awt.event.KeyListener; 107 import java.awt.event.WindowAdapter; 108 import java.awt.event.WindowEvent; 109 import java.io.IOException; 110 import java.io.UnsupportedEncodingException; 111 import java.net.URL; 112 import java.net.URLEncoder; 113 import java.util.Arrays; 114 import java.util.Deque; 115 import java.util.HashMap; 116 import java.util.List; 117 import java.util.Map; 118 import java.util.StringTokenizer; 119 import java.util.Vector; 120 121 import org.jmol.viewer.Viewer; 122 123 public class AlignFrame extends EmbmenuFrame implements ActionListener, 124 ItemListener, KeyListener, AlignViewControllerGuiI 125 { 126 public AlignViewControllerI avc; 127 128 public AlignmentPanel alignPanel; 129 130 public AlignViewport viewport; 131 132 // width and height may be overridden by applet parameters 133 int frameWidth = 700; 134 135 int frameHeight = 500; 136 137 String jalviewServletURL; 138 139 /* 140 * Flag for showing autocalculated consensus above or below other consensus 141 * rows 142 */ 143 private boolean showAutoCalculatedAbove; 144 145 private SequenceAnnotationOrder annotationSortOrder; 146 147 /** 148 * Constructor that creates the frame and adds it to the display. 149 * 150 * @param al 151 * @param applet 152 * @param title 153 * @param embedded 154 */ AlignFrame(AlignmentI al, JalviewLite applet, String title, boolean embedded)155 public AlignFrame(AlignmentI al, JalviewLite applet, String title, 156 boolean embedded) 157 { 158 this(al, applet, title, embedded, true); 159 } 160 161 /** 162 * Constructor that optionally allows the frame to be displayed or only 163 * created. 164 * 165 * @param al 166 * @param applet 167 * @param title 168 * @param embedded 169 * @param addToDisplay 170 */ AlignFrame(AlignmentI al, JalviewLite applet, String title, boolean embedded, boolean addToDisplay)171 public AlignFrame(AlignmentI al, JalviewLite applet, String title, 172 boolean embedded, boolean addToDisplay) 173 { 174 this(al, null, null, applet, title, embedded, addToDisplay); 175 } 176 AlignFrame(AlignmentI al, SequenceI[] hiddenSeqs, HiddenColumns hidden, JalviewLite applet, String title, boolean embedded)177 public AlignFrame(AlignmentI al, SequenceI[] hiddenSeqs, 178 HiddenColumns hidden, JalviewLite applet, String title, 179 boolean embedded) 180 { 181 this(al, hiddenSeqs, hidden, applet, title, embedded, true); 182 } 183 AlignFrame(AlignmentI al, SequenceI[] hiddenSeqs, HiddenColumns hidden, JalviewLite applet, String title, boolean embedded, boolean addToDisplay)184 public AlignFrame(AlignmentI al, SequenceI[] hiddenSeqs, 185 HiddenColumns hidden, JalviewLite applet, String title, 186 boolean embedded, boolean addToDisplay) 187 { 188 if (applet != null) 189 { 190 jalviewServletURL = applet.getParameter("APPLICATION_URL"); 191 } 192 193 try 194 { 195 jbInit(); 196 } catch (Exception ex) 197 { 198 ex.printStackTrace(); 199 } 200 // need to get window geometry before we calculate alignment layout 201 if (applet != null) 202 { 203 String param; 204 try 205 { 206 param = applet.getParameter("windowWidth"); 207 if (param != null) 208 { 209 int width = Integer.parseInt(param); 210 frameWidth = width; 211 } 212 param = applet.getParameter("windowHeight"); 213 if (param != null) 214 { 215 int height = Integer.parseInt(param); 216 frameHeight = height; 217 } 218 } catch (Exception ex) 219 { 220 } 221 } 222 viewport = new AlignViewport(al, applet); 223 224 if (hiddenSeqs != null && hiddenSeqs.length > 0) 225 { 226 viewport.hideSequence(hiddenSeqs); 227 } 228 if (hidden != null) 229 { 230 viewport.getAlignment().setHiddenColumns(hidden); 231 } 232 viewport.setScaleAboveWrapped(scaleAbove.getState()); 233 234 alignPanel = new AlignmentPanel(this, viewport); 235 avc = new jalview.controller.AlignViewController(this, viewport, 236 alignPanel); 237 viewport.updateConservation(alignPanel); 238 viewport.updateConsensus(alignPanel); 239 240 displayNonconservedMenuItem.setState(viewport.getShowUnconserved()); 241 followMouseOverFlag.setState(viewport.isFollowHighlight()); 242 showGroupConsensus.setState(viewport.isShowGroupConsensus()); 243 showGroupConservation.setState(viewport.isShowGroupConservation()); 244 showConsensusHistogram.setState(viewport.isShowConsensusHistogram()); 245 showSequenceLogo.setState(viewport.isShowSequenceLogo()); 246 normSequenceLogo.setState(viewport.isNormaliseSequenceLogo()); 247 applyToAllGroups.setState(viewport.getColourAppliesToAllGroups()); 248 annotationPanelMenuItem.setState(viewport.isShowAnnotation()); 249 showAlignmentAnnotations.setEnabled(annotationPanelMenuItem.getState()); 250 showSequenceAnnotations.setEnabled(annotationPanelMenuItem.getState()); 251 showAlignmentAnnotations.setState(true); 252 showSequenceAnnotations.setState(false); 253 254 seqLimits.setState(viewport.getShowJVSuffix()); 255 256 if (applet != null) 257 { 258 String param = applet.getParameter("sortBy"); 259 if (param != null) 260 { 261 if (param.equalsIgnoreCase("Id")) 262 { 263 sortIDMenuItem_actionPerformed(); 264 } 265 else if (param.equalsIgnoreCase("Pairwise Identity")) 266 { 267 sortPairwiseMenuItem_actionPerformed(); 268 } 269 else if (param.equalsIgnoreCase("Length")) 270 { 271 sortLengthMenuItem_actionPerformed(); 272 } 273 } 274 275 param = applet.getParameter("wrap"); 276 if (param != null) 277 { 278 if (param.equalsIgnoreCase("true")) 279 { 280 wrapMenuItem.setState(true); 281 wrapMenuItem_actionPerformed(); 282 } 283 } 284 param = applet.getParameter("centrecolumnlabels"); 285 if (param != null) 286 { 287 centreColumnLabelFlag.setState(true); 288 centreColumnLabelFlag_stateChanged(); 289 } 290 291 } 292 if (viewport.getAlignment().isNucleotide()) 293 { 294 conservationMenuItem.setEnabled(false); 295 clustalColour.setEnabled(false); 296 BLOSUM62Colour.setEnabled(false); 297 zappoColour.setEnabled(false); 298 taylorColour.setEnabled(false); 299 hydrophobicityColour.setEnabled(false); 300 helixColour.setEnabled(false); 301 strandColour.setEnabled(false); 302 turnColour.setEnabled(false); 303 buriedColour.setEnabled(false); 304 viewport.updateStrucConsensus(alignPanel); 305 if (viewport.getAlignment().hasRNAStructure()) 306 { 307 RNAHelixColour.setEnabled(true); 308 } 309 else 310 { 311 RNAHelixColour.setEnabled(false); 312 } 313 } 314 else 315 { 316 RNAHelixColour.setEnabled(false); 317 purinePyrimidineColour.setEnabled(false); 318 nucleotideColour.setEnabled(false); 319 } 320 // Some JVMS send keyevents to Top frame or lowest panel, 321 // Havent worked out why yet. So add to both this frame and seqCanvas for 322 // now 323 this.addKeyListener(this); 324 alignPanel.seqPanel.seqCanvas.addKeyListener(this); 325 alignPanel.idPanel.idCanvas.addKeyListener(this); 326 alignPanel.scalePanel.addKeyListener(this); 327 alignPanel.annotationPanel.addKeyListener(this); 328 alignPanel.annotationPanelHolder.addKeyListener(this); 329 alignPanel.annotationSpaceFillerHolder.addKeyListener(this); 330 alignPanel.alabels.addKeyListener(this); 331 332 setAnnotationsVisibility(); 333 334 if (addToDisplay) 335 { 336 addToDisplay(embedded); 337 } 338 } 339 340 /** 341 * @param embedded 342 */ addToDisplay(boolean embedded)343 public void addToDisplay(boolean embedded) 344 { 345 createAlignFrameWindow(embedded); 346 validate(); 347 alignPanel.adjustAnnotationHeight(); 348 alignPanel.paintAlignment(true, true); 349 } 350 getAlignViewport()351 public AlignViewport getAlignViewport() 352 { 353 return viewport; 354 } 355 getSeqcanvas()356 public SeqCanvas getSeqcanvas() 357 { 358 return alignPanel.seqPanel.seqCanvas; 359 } 360 361 /** 362 * Load a features file onto the alignment 363 * 364 * @param file 365 * file URL, content, or other resolvable path 366 * @param type 367 * is protocol for accessing data referred to by file 368 */ 369 parseFeaturesFile(String file, DataSourceType type)370 public boolean parseFeaturesFile(String file, DataSourceType type) 371 { 372 return parseFeaturesFile(file, type, true); 373 } 374 375 /** 376 * Load a features file onto the alignment 377 * 378 * @param file 379 * file URL, content, or other resolvable path 380 * @param sourceType 381 * is protocol for accessing data referred to by file 382 * @param autoenabledisplay 383 * when true, display features flag will be automatically enabled if 384 * features are loaded 385 * @return true if data parsed as a features file 386 */ parseFeaturesFile(String file, DataSourceType sourceType, boolean autoenabledisplay)387 public boolean parseFeaturesFile(String file, DataSourceType sourceType, 388 boolean autoenabledisplay) 389 { 390 boolean featuresFile = false; 391 try 392 { 393 Map<String, FeatureColourI> colours = alignPanel.seqPanel.seqCanvas 394 .getFeatureRenderer().getFeatureColours(); 395 boolean relaxedIdMatching = viewport.applet 396 .getDefaultParameter("relaxedidmatch", false); 397 featuresFile = new FeaturesFile(file, sourceType).parse( 398 viewport.getAlignment(), colours, true, relaxedIdMatching); 399 } catch (Exception ex) 400 { 401 ex.printStackTrace(); 402 } 403 404 if (featuresFile) 405 { 406 if (autoenabledisplay) 407 { 408 viewport.setShowSequenceFeatures(true); 409 sequenceFeatures.setState(true); 410 } 411 if (alignPanel.seqPanel.seqCanvas.fr != null) 412 { 413 // update the min/max ranges where necessary 414 alignPanel.seqPanel.seqCanvas.fr.findAllFeatures(true); 415 } 416 if (viewport.featureSettings != null) 417 { 418 viewport.featureSettings.refreshTable(); 419 } 420 alignPanel.paintAlignment(true, true); 421 statusBar.setText(MessageManager 422 .getString("label.successfully_added_features_alignment")); 423 } 424 return featuresFile; 425 } 426 427 @Override keyPressed(KeyEvent evt)428 public void keyPressed(KeyEvent evt) 429 { 430 ViewportRanges ranges = viewport.getRanges(); 431 432 if (viewport.cursorMode 433 && ((evt.getKeyCode() >= KeyEvent.VK_0 434 && evt.getKeyCode() <= KeyEvent.VK_9) 435 || (evt.getKeyCode() >= KeyEvent.VK_NUMPAD0 436 && evt.getKeyCode() <= KeyEvent.VK_NUMPAD9)) 437 && Character.isDigit(evt.getKeyChar())) 438 { 439 alignPanel.seqPanel.numberPressed(evt.getKeyChar()); 440 } 441 442 switch (evt.getKeyCode()) 443 { 444 case 27: // escape key 445 deselectAllSequenceMenuItem_actionPerformed(); 446 447 alignPanel.alabels.cancelDrag(); 448 break; 449 case KeyEvent.VK_X: 450 if (evt.isControlDown() || evt.isMetaDown()) 451 { 452 cut_actionPerformed(); 453 } 454 break; 455 case KeyEvent.VK_C: 456 if (viewport.cursorMode && !evt.isControlDown()) 457 { 458 alignPanel.seqPanel.setCursorColumn(); 459 } 460 if (evt.isControlDown() || evt.isMetaDown()) 461 { 462 copy_actionPerformed(); 463 } 464 break; 465 case KeyEvent.VK_V: 466 if (evt.isControlDown()) 467 { 468 paste(evt.isShiftDown()); 469 } 470 break; 471 case KeyEvent.VK_A: 472 if (evt.isControlDown() || evt.isMetaDown()) 473 { 474 selectAllSequenceMenuItem_actionPerformed(); 475 } 476 break; 477 case KeyEvent.VK_DOWN: 478 if (viewport.cursorMode) 479 { 480 alignPanel.seqPanel.moveCursor(0, 1); 481 } 482 else 483 { 484 moveSelectedSequences(false); 485 } 486 break; 487 488 case KeyEvent.VK_UP: 489 if (viewport.cursorMode) 490 { 491 alignPanel.seqPanel.moveCursor(0, -1); 492 } 493 else 494 { 495 moveSelectedSequences(true); 496 } 497 break; 498 499 case KeyEvent.VK_LEFT: 500 if (evt.isAltDown() || !viewport.cursorMode) 501 { 502 slideSequences(false, alignPanel.seqPanel.getKeyboardNo1()); 503 } 504 else 505 { 506 alignPanel.seqPanel.moveCursor(-1, 0); 507 } 508 break; 509 510 case KeyEvent.VK_RIGHT: 511 if (evt.isAltDown() || !viewport.cursorMode) 512 { 513 slideSequences(true, alignPanel.seqPanel.getKeyboardNo1()); 514 } 515 else 516 { 517 alignPanel.seqPanel.moveCursor(1, 0); 518 } 519 break; 520 521 case KeyEvent.VK_SPACE: 522 if (viewport.cursorMode) 523 { 524 alignPanel.seqPanel.insertGapAtCursor(evt.isControlDown() 525 || evt.isShiftDown() || evt.isAltDown()); 526 } 527 break; 528 529 case KeyEvent.VK_DELETE: 530 case KeyEvent.VK_BACK_SPACE: 531 if (viewport.cursorMode) 532 { 533 alignPanel.seqPanel.deleteGapAtCursor(evt.isControlDown() 534 || evt.isShiftDown() || evt.isAltDown()); 535 } 536 else 537 { 538 cut_actionPerformed(); 539 alignPanel.seqPanel.seqCanvas.repaint(); 540 } 541 break; 542 543 case KeyEvent.VK_S: 544 if (viewport.cursorMode) 545 { 546 alignPanel.seqPanel.setCursorRow(); 547 } 548 break; 549 case KeyEvent.VK_P: 550 if (viewport.cursorMode) 551 { 552 alignPanel.seqPanel.setCursorPosition(); 553 } 554 break; 555 556 case KeyEvent.VK_ENTER: 557 case KeyEvent.VK_COMMA: 558 if (viewport.cursorMode) 559 { 560 alignPanel.seqPanel.setCursorRowAndColumn(); 561 } 562 break; 563 564 case KeyEvent.VK_Q: 565 if (viewport.cursorMode) 566 { 567 alignPanel.seqPanel.setSelectionAreaAtCursor(true); 568 } 569 break; 570 case KeyEvent.VK_M: 571 if (viewport.cursorMode) 572 { 573 alignPanel.seqPanel.setSelectionAreaAtCursor(false); 574 } 575 break; 576 577 case KeyEvent.VK_F2: 578 viewport.cursorMode = !viewport.cursorMode; 579 statusBar.setText(MessageManager 580 .formatMessage("label.keyboard_editing_mode", new String[] 581 { (viewport.cursorMode ? "on" : "off") })); 582 if (viewport.cursorMode) 583 { 584 alignPanel.seqPanel.seqCanvas.cursorX = ranges.getStartRes(); 585 alignPanel.seqPanel.seqCanvas.cursorY = ranges.getStartSeq(); 586 } 587 break; 588 589 case KeyEvent.VK_F: 590 if (evt.isControlDown()) 591 { 592 findMenuItem_actionPerformed(); 593 } 594 break; 595 596 case KeyEvent.VK_H: 597 { 598 boolean toggleSeqs = !evt.isControlDown(); 599 boolean toggleCols = !evt.isShiftDown(); 600 toggleHiddenRegions(toggleSeqs, toggleCols); 601 break; 602 } 603 604 case KeyEvent.VK_PAGE_UP: 605 ranges.pageUp(); 606 break; 607 608 case KeyEvent.VK_PAGE_DOWN: 609 ranges.pageDown(); 610 break; 611 612 case KeyEvent.VK_Z: 613 if (evt.isControlDown()) 614 { 615 undoMenuItem_actionPerformed(); 616 } 617 break; 618 619 case KeyEvent.VK_Y: 620 if (evt.isControlDown()) 621 { 622 redoMenuItem_actionPerformed(); 623 } 624 break; 625 626 case KeyEvent.VK_L: 627 if (evt.isControlDown()) 628 { 629 trimAlignment(true); 630 } 631 break; 632 633 case KeyEvent.VK_R: 634 if (evt.isControlDown()) 635 { 636 trimAlignment(false); 637 } 638 break; 639 640 case KeyEvent.VK_E: 641 if (evt.isControlDown()) 642 { 643 if (evt.isShiftDown()) 644 { 645 this.removeAllGapsMenuItem_actionPerformed(); 646 } 647 else 648 { 649 removeGappedColumnMenuItem_actionPerformed(); 650 } 651 } 652 break; 653 case KeyEvent.VK_I: 654 if (evt.isControlDown()) 655 { 656 if (evt.isAltDown()) 657 { 658 invertColSel_actionPerformed(); 659 } 660 else 661 { 662 invertSequenceMenuItem_actionPerformed(); 663 } 664 } 665 break; 666 667 case KeyEvent.VK_G: 668 if (evt.isControlDown()) 669 { 670 if (evt.isShiftDown()) 671 { 672 this.unGroup_actionPerformed(); 673 } 674 else 675 { 676 this.createGroup_actionPerformed(); 677 } 678 } 679 break; 680 681 case KeyEvent.VK_U: 682 if (evt.isControlDown()) 683 { 684 this.deleteGroups_actionPerformed(); 685 } 686 break; 687 688 case KeyEvent.VK_T: 689 if (evt.isControlDown()) 690 { 691 newView(null); 692 } 693 break; 694 695 } 696 // TODO: repaint flags set only if the keystroke warrants it 697 alignPanel.paintAlignment(true, true); 698 } 699 700 /** 701 * called by key handler and the hide all/show all menu items 702 * 703 * @param toggleSeqs 704 * @param toggleCols 705 */ toggleHiddenRegions(boolean toggleSeqs, boolean toggleCols)706 private void toggleHiddenRegions(boolean toggleSeqs, boolean toggleCols) 707 { 708 boolean hide = false; 709 SequenceGroup sg = viewport.getSelectionGroup(); 710 if (!toggleSeqs && !toggleCols) 711 { 712 // Hide everything by the current selection - this is a hack - we do the 713 // invert and then hide 714 // first check that there will be visible columns after the invert. 715 if (viewport.hasSelectedColumns() || (sg != null && sg.getSize() > 0 716 && sg.getStartRes() <= sg.getEndRes())) 717 { 718 // now invert the sequence set, if required - empty selection implies 719 // that no hiding is required. 720 if (sg != null) 721 { 722 invertSequenceMenuItem_actionPerformed(); 723 sg = viewport.getSelectionGroup(); 724 toggleSeqs = true; 725 726 } 727 viewport.expandColSelection(sg, true); 728 // finally invert the column selection and get the new sequence 729 // selection and indicate it should be hidden. 730 invertColSel_actionPerformed(); 731 toggleCols = true; 732 } 733 } 734 735 if (toggleSeqs) 736 { 737 if (sg != null && sg.getSize() != viewport.getAlignment().getHeight()) 738 { 739 hide = true; 740 viewport.hideAllSelectedSeqs(); 741 } 742 else if (!(toggleCols && viewport.hasSelectedColumns())) 743 { 744 viewport.showAllHiddenSeqs(); 745 } 746 } 747 748 if (toggleCols) 749 { 750 if (viewport.hasSelectedColumns()) 751 { 752 viewport.hideSelectedColumns(); 753 if (!toggleSeqs) 754 { 755 viewport.setSelectionGroup(sg); 756 } 757 } 758 else if (!hide) 759 { 760 viewport.showAllHiddenColumns(); 761 } 762 viewport.sendSelection(); 763 } 764 } 765 766 @Override keyReleased(KeyEvent evt)767 public void keyReleased(KeyEvent evt) 768 { 769 } 770 771 @Override keyTyped(KeyEvent evt)772 public void keyTyped(KeyEvent evt) 773 { 774 } 775 776 @Override itemStateChanged(ItemEvent evt)777 public void itemStateChanged(ItemEvent evt) 778 { 779 final Object source = evt.getSource(); 780 if (source == displayNonconservedMenuItem) 781 { 782 displayNonconservedMenuItem_actionPerformed(); 783 } 784 else if (source == colourTextMenuItem) 785 { 786 colourTextMenuItem_actionPerformed(); 787 } 788 else if (source == wrapMenuItem) 789 { 790 wrapMenuItem_actionPerformed(); 791 } 792 else if (source == scaleAbove) 793 { 794 viewport.setScaleAboveWrapped(scaleAbove.getState()); 795 } 796 else if (source == scaleLeft) 797 { 798 viewport.setScaleLeftWrapped(scaleLeft.getState()); 799 } 800 else if (source == scaleRight) 801 { 802 viewport.setScaleRightWrapped(scaleRight.getState()); 803 } 804 else if (source == seqLimits) 805 { 806 seqLimits_itemStateChanged(); 807 } 808 else if (source == viewBoxesMenuItem) 809 { 810 viewport.setShowBoxes(viewBoxesMenuItem.getState()); 811 } 812 else if (source == viewTextMenuItem) 813 { 814 viewport.setShowText(viewTextMenuItem.getState()); 815 } 816 else if (source == renderGapsMenuItem) 817 { 818 viewport.setRenderGaps(renderGapsMenuItem.getState()); 819 } 820 else if (source == annotationPanelMenuItem) 821 { 822 boolean showAnnotations = annotationPanelMenuItem.getState(); 823 showAlignmentAnnotations.setEnabled(showAnnotations); 824 showSequenceAnnotations.setEnabled(showAnnotations); 825 viewport.setShowAnnotation(showAnnotations); 826 alignPanel.setAnnotationVisible(showAnnotations); 827 } 828 else if (source == sequenceFeatures) 829 { 830 viewport.setShowSequenceFeatures(sequenceFeatures.getState()); 831 alignPanel.seqPanel.seqCanvas.repaint(); 832 } 833 else if (source == showAlignmentAnnotations) 834 { 835 setAnnotationsVisibility(); 836 } 837 else if (source == showSequenceAnnotations) 838 { 839 setAnnotationsVisibility(); 840 } 841 else if (source == sortAnnBySequence) 842 { 843 boolean newState = sortAnnBySequence.getState(); 844 sortAnnByLabel.setState(false); 845 setAnnotationSortOrder( 846 newState ? SequenceAnnotationOrder.SEQUENCE_AND_LABEL 847 : SequenceAnnotationOrder.NONE); 848 setViewportAnnotationOrder(); 849 } 850 else if (source == sortAnnByLabel) 851 { 852 boolean newState = sortAnnByLabel.getState(); 853 sortAnnBySequence.setState(false); 854 setAnnotationSortOrder( 855 newState ? SequenceAnnotationOrder.LABEL_AND_SEQUENCE 856 : SequenceAnnotationOrder.NONE); 857 setViewportAnnotationOrder(); 858 } 859 else if (source == showAutoFirst) 860 { 861 showAutoLast.setState(!showAutoFirst.getState()); 862 setShowAutoCalculatedAbove(showAutoFirst.getState()); 863 setViewportAnnotationOrder(); 864 } 865 else if (source == showAutoLast) 866 { 867 showAutoFirst.setState(!showAutoLast.getState()); 868 setShowAutoCalculatedAbove(showAutoFirst.getState()); 869 setViewportAnnotationOrder(); 870 } 871 else if (source == conservationMenuItem) 872 { 873 conservationMenuItem_actionPerformed(); 874 } 875 else if (source == abovePIDThreshold) 876 { 877 abovePIDThreshold_actionPerformed(); 878 } 879 else if (source == applyToAllGroups) 880 { 881 viewport.setColourAppliesToAllGroups(applyToAllGroups.getState()); 882 } 883 else if (source == autoCalculate) 884 { 885 viewport.autoCalculateConsensus = autoCalculate.getState(); 886 } 887 else if (source == sortByTree) 888 { 889 viewport.sortByTree = sortByTree.getState(); 890 } 891 else if (source == this.centreColumnLabelFlag) 892 { 893 centreColumnLabelFlag_stateChanged(); 894 } 895 else if (source == this.followMouseOverFlag) 896 { 897 mouseOverFlag_stateChanged(); 898 } 899 else if (source == showGroupConsensus) 900 { 901 showGroupConsensus_actionPerformed(); 902 } 903 else if (source == showGroupConservation) 904 { 905 showGroupConservation_actionPerformed(); 906 } 907 else if (source == showSequenceLogo) 908 { 909 showSequenceLogo_actionPerformed(); 910 } 911 else if (source == normSequenceLogo) 912 { 913 normSequenceLogo_actionPerformed(); 914 } 915 else if (source == showConsensusHistogram) 916 { 917 showConsensusHistogram_actionPerformed(); 918 } 919 else if (source == applyAutoAnnotationSettings) 920 { 921 applyAutoAnnotationSettings_actionPerformed(); 922 } 923 // TODO: repaint flags set only if warranted 924 alignPanel.paintAlignment(true, true); 925 } 926 927 /** 928 * Set the visibility state of sequence-related and/or alignment-related 929 * annotations depending on checkbox selections, and repaint. 930 * 931 * @param visible 932 */ setAnnotationsVisibility()933 private void setAnnotationsVisibility() 934 { 935 boolean showForAlignment = showAlignmentAnnotations.getState(); 936 boolean showForSequences = showSequenceAnnotations.getState(); 937 if (alignPanel.getAlignment().getAlignmentAnnotation() != null) 938 { 939 for (AlignmentAnnotation aa : alignPanel.getAlignment() 940 .getAlignmentAnnotation()) 941 { 942 boolean visible = (aa.sequenceRef == null ? showForAlignment 943 : showForSequences); 944 aa.visible = visible; 945 } 946 } 947 alignPanel.validateAnnotationDimensions(true); 948 validate(); 949 repaint(); 950 } 951 setAnnotationSortOrder(SequenceAnnotationOrder order)952 private void setAnnotationSortOrder(SequenceAnnotationOrder order) 953 { 954 this.annotationSortOrder = order; 955 } 956 957 /** 958 * Set flags on the viewport that control annotation ordering 959 */ setViewportAnnotationOrder()960 private void setViewportAnnotationOrder() 961 { 962 this.alignPanel.av.setSortAnnotationsBy(this.annotationSortOrder); 963 this.alignPanel.av 964 .setShowAutocalculatedAbove(this.showAutoCalculatedAbove); 965 } 966 setShowAutoCalculatedAbove(boolean showAbove)967 private void setShowAutoCalculatedAbove(boolean showAbove) 968 { 969 this.showAutoCalculatedAbove = showAbove; 970 } 971 mouseOverFlag_stateChanged()972 private void mouseOverFlag_stateChanged() 973 { 974 viewport.setFollowHighlight(followMouseOverFlag.getState()); 975 // TODO: could kick the scrollTo mechanism to reset view for current 976 // searchresults. 977 } 978 centreColumnLabelFlag_stateChanged()979 private void centreColumnLabelFlag_stateChanged() 980 { 981 viewport.centreColumnLabels = centreColumnLabelFlag.getState(); 982 this.alignPanel.annotationPanel.repaint(); 983 } 984 985 @Override actionPerformed(ActionEvent evt)986 public void actionPerformed(ActionEvent evt) 987 { 988 viewport.applet.currentAlignFrame = this; 989 990 Object source = evt.getSource(); 991 992 if (source == inputText) 993 { 994 inputText_actionPerformed(); 995 } 996 else if (source == loadTree) 997 { 998 loadTree_actionPerformed(); 999 } 1000 else if (source == loadApplication) 1001 { 1002 launchFullApplication(); 1003 } 1004 else if (source == loadAnnotations) 1005 { 1006 loadAnnotations(); 1007 } 1008 else if (source == outputAnnotations) 1009 { 1010 outputAnnotations(true); 1011 } 1012 else if (source == outputFeatures) 1013 { 1014 outputFeatures(true, "Jalview"); 1015 } 1016 else if (source == closeMenuItem) 1017 { 1018 closeMenuItem_actionPerformed(); 1019 } 1020 else if (source == copy) 1021 { 1022 copy_actionPerformed(); 1023 } 1024 else if (source == undoMenuItem) 1025 { 1026 undoMenuItem_actionPerformed(); 1027 } 1028 else if (source == redoMenuItem) 1029 { 1030 redoMenuItem_actionPerformed(); 1031 } 1032 else if (source == inputText) 1033 { 1034 inputText_actionPerformed(); 1035 } 1036 else if (source == closeMenuItem) 1037 { 1038 closeMenuItem_actionPerformed(); 1039 } 1040 else if (source == undoMenuItem) 1041 { 1042 undoMenuItem_actionPerformed(); 1043 } 1044 else if (source == redoMenuItem) 1045 { 1046 redoMenuItem_actionPerformed(); 1047 } 1048 else if (source == copy) 1049 { 1050 copy_actionPerformed(); 1051 } 1052 else if (source == pasteNew) 1053 { 1054 pasteNew_actionPerformed(); 1055 } 1056 else if (source == pasteThis) 1057 { 1058 pasteThis_actionPerformed(); 1059 } 1060 else if (source == cut) 1061 { 1062 cut_actionPerformed(); 1063 } 1064 else if (source == delete) 1065 { 1066 delete_actionPerformed(); 1067 } 1068 else if (source == createGroup) 1069 { 1070 createGroup_actionPerformed(); 1071 } 1072 else if (source == unGroup) 1073 { 1074 unGroup_actionPerformed(); 1075 } 1076 else if (source == grpsFromSelection) 1077 { 1078 makeGrpsFromSelection_actionPerformed(); 1079 } 1080 else if (source == deleteGroups) 1081 { 1082 deleteGroups_actionPerformed(); 1083 } 1084 else if (source == selectAllSequenceMenuItem) 1085 { 1086 selectAllSequenceMenuItem_actionPerformed(); 1087 } 1088 else if (source == deselectAllSequenceMenuItem) 1089 { 1090 deselectAllSequenceMenuItem_actionPerformed(); 1091 } 1092 else if (source == invertSequenceMenuItem) 1093 { 1094 invertSequenceMenuItem_actionPerformed(); 1095 // uncomment to slave sequence selections in split frame 1096 // viewport.sendSelection(); 1097 } 1098 else if (source == invertColSel) 1099 { 1100 viewport.invertColumnSelection(); 1101 alignPanel.paintAlignment(false, false); 1102 viewport.sendSelection(); 1103 } 1104 else if (source == remove2LeftMenuItem) 1105 { 1106 trimAlignment(true); 1107 } 1108 else if (source == remove2RightMenuItem) 1109 { 1110 trimAlignment(false); 1111 } 1112 else if (source == removeGappedColumnMenuItem) 1113 { 1114 removeGappedColumnMenuItem_actionPerformed(); 1115 } 1116 else if (source == removeAllGapsMenuItem) 1117 { 1118 removeAllGapsMenuItem_actionPerformed(); 1119 } 1120 else if (source == findMenuItem) 1121 { 1122 findMenuItem_actionPerformed(); 1123 } 1124 else if (source == font) 1125 { 1126 new FontChooser(alignPanel); 1127 } 1128 else if (source == newView) 1129 { 1130 newView(null); 1131 } 1132 else if (source == showColumns) 1133 { 1134 viewport.showAllHiddenColumns(); 1135 alignPanel.paintAlignment(true, true); 1136 viewport.sendSelection(); 1137 } 1138 else if (source == showSeqs) 1139 { 1140 viewport.showAllHiddenSeqs(); 1141 alignPanel.paintAlignment(true, true); 1142 // uncomment if we want to slave sequence selections in split frame 1143 // viewport.sendSelection(); 1144 } 1145 else if (source == hideColumns) 1146 { 1147 viewport.hideSelectedColumns(); 1148 alignPanel.paintAlignment(true, true); 1149 viewport.sendSelection(); 1150 } 1151 else if (source == hideSequences 1152 && viewport.getSelectionGroup() != null) 1153 { 1154 viewport.hideAllSelectedSeqs(); 1155 alignPanel.paintAlignment(true, true); 1156 // uncomment if we want to slave sequence selections in split frame 1157 // viewport.sendSelection(); 1158 } 1159 else if (source == hideAllButSelection) 1160 { 1161 toggleHiddenRegions(false, false); 1162 alignPanel.paintAlignment(true, true); 1163 viewport.sendSelection(); 1164 } 1165 else if (source == hideAllSelection) 1166 { 1167 SequenceGroup sg = viewport.getSelectionGroup(); 1168 viewport.expandColSelection(sg, false); 1169 viewport.hideAllSelectedSeqs(); 1170 viewport.hideSelectedColumns(); 1171 alignPanel.paintAlignment(true, true); 1172 viewport.sendSelection(); 1173 } 1174 else if (source == showAllHidden) 1175 { 1176 viewport.showAllHiddenColumns(); 1177 viewport.showAllHiddenSeqs(); 1178 alignPanel.paintAlignment(true, true); 1179 viewport.sendSelection(); 1180 } 1181 else if (source == showGroupConsensus) 1182 { 1183 showGroupConsensus_actionPerformed(); 1184 } 1185 else if (source == showGroupConservation) 1186 { 1187 showGroupConservation_actionPerformed(); 1188 } 1189 else if (source == showSequenceLogo) 1190 { 1191 showSequenceLogo_actionPerformed(); 1192 } 1193 else if (source == normSequenceLogo) 1194 { 1195 normSequenceLogo_actionPerformed(); 1196 } 1197 else if (source == showConsensusHistogram) 1198 { 1199 showConsensusHistogram_actionPerformed(); 1200 } 1201 else if (source == applyAutoAnnotationSettings) 1202 { 1203 applyAutoAnnotationSettings_actionPerformed(); 1204 } 1205 else if (source == featureSettings) 1206 { 1207 showFeatureSettingsUI(); 1208 } 1209 else if (source == alProperties) 1210 { 1211 StringBuffer contents = new jalview.io.AlignmentProperties( 1212 viewport.getAlignment()).formatAsString(); 1213 CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this); 1214 cap.setText(contents.toString()); 1215 Frame frame = new Frame(); 1216 frame.add(cap); 1217 jalview.bin.JalviewLite.addFrame(frame, MessageManager 1218 .formatMessage("label.alignment_properties", new String[] 1219 { getTitle() }), 400, 250); 1220 } 1221 else if (source == overviewMenuItem) 1222 { 1223 overviewMenuItem_actionPerformed(); 1224 } 1225 else if (source == noColourmenuItem) 1226 { 1227 changeColour(null); 1228 } 1229 else if (source == clustalColour) 1230 { 1231 abovePIDThreshold.setState(false); 1232 changeColour(new ClustalxColourScheme(viewport.getAlignment(), null)); 1233 } 1234 else if (source == zappoColour) 1235 { 1236 changeColour(new ZappoColourScheme()); 1237 } 1238 else if (source == taylorColour) 1239 { 1240 changeColour(new TaylorColourScheme()); 1241 } 1242 else if (source == hydrophobicityColour) 1243 { 1244 changeColour(new HydrophobicColourScheme()); 1245 } 1246 else if (source == helixColour) 1247 { 1248 changeColour(new HelixColourScheme()); 1249 } 1250 else if (source == strandColour) 1251 { 1252 changeColour(new StrandColourScheme()); 1253 } 1254 else if (source == turnColour) 1255 { 1256 changeColour(new TurnColourScheme()); 1257 } 1258 else if (source == buriedColour) 1259 { 1260 changeColour(new BuriedColourScheme()); 1261 } 1262 else if (source == nucleotideColour) 1263 { 1264 changeColour(new NucleotideColourScheme()); 1265 } 1266 else if (source == purinePyrimidineColour) 1267 { 1268 changeColour(new PurinePyrimidineColourScheme()); 1269 } 1270 // else if (source == RNAInteractionColour) 1271 // { 1272 // changeColour(new RNAInteractionColourScheme()); 1273 // } 1274 else if (source == RNAHelixColour) 1275 { 1276 changeColour(new RNAHelicesColour(viewport.getAlignment())); 1277 // new RNAHelicesColourChooser(viewport, alignPanel); 1278 } 1279 else if (source == modifyPID) 1280 { 1281 modifyPID_actionPerformed(); 1282 } 1283 else if (source == modifyConservation) 1284 { 1285 modifyConservation_actionPerformed(); 1286 } 1287 else if (source == userDefinedColour) 1288 { 1289 new UserDefinedColours(alignPanel, null); 1290 } 1291 else if (source == PIDColour) 1292 { 1293 changeColour(new PIDColourScheme()); 1294 } 1295 else if (source == BLOSUM62Colour) 1296 { 1297 changeColour(new Blosum62ColourScheme()); 1298 } 1299 else if (source == tcoffeeColour) 1300 { 1301 changeColour(new TCoffeeColourScheme(alignPanel.getAlignment())); 1302 } 1303 else if (source == annotationColour) 1304 { 1305 new AnnotationColourChooser(viewport, alignPanel); 1306 } 1307 else if (source == annotationColumnSelection) 1308 { 1309 new AnnotationColumnChooser(viewport, alignPanel); 1310 } 1311 else if (source == sortPairwiseMenuItem) 1312 { 1313 sortPairwiseMenuItem_actionPerformed(); 1314 } 1315 else if (source == sortIDMenuItem) 1316 { 1317 sortIDMenuItem_actionPerformed(); 1318 } 1319 else if (source == sortLengthMenuItem) 1320 { 1321 sortLengthMenuItem_actionPerformed(); 1322 } 1323 else if (source == sortGroupMenuItem) 1324 { 1325 sortGroupMenuItem_actionPerformed(); 1326 } 1327 else if (source == removeRedundancyMenuItem) 1328 { 1329 removeRedundancyMenuItem_actionPerformed(); 1330 } 1331 else if (source == pairwiseAlignmentMenuItem) 1332 { 1333 pairwiseAlignmentMenuItem_actionPerformed(); 1334 } 1335 else if (source == PCAMenuItem) 1336 { 1337 PCAMenuItem_actionPerformed(); 1338 } 1339 else if (source == averageDistanceTreeMenuItem) 1340 { 1341 averageDistanceTreeMenuItem_actionPerformed(); 1342 } 1343 else if (source == neighbourTreeMenuItem) 1344 { 1345 neighbourTreeMenuItem_actionPerformed(); 1346 } 1347 else if (source == njTreeBlosumMenuItem) 1348 { 1349 njTreeBlosumMenuItem_actionPerformed(); 1350 } 1351 else if (source == avDistanceTreeBlosumMenuItem) 1352 { 1353 avTreeBlosumMenuItem_actionPerformed(); 1354 } 1355 else if (source == documentation) 1356 { 1357 documentation_actionPerformed(); 1358 } 1359 else if (source == about) 1360 { 1361 about_actionPerformed(); 1362 } 1363 1364 } 1365 inputText_actionPerformed()1366 public void inputText_actionPerformed() 1367 { 1368 CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this); 1369 Frame frame = new Frame(); 1370 frame.add(cap); 1371 jalview.bin.JalviewLite.addFrame(frame, 1372 MessageManager.getString("label.input_cut_paste"), 500, 500); 1373 } 1374 outputText_actionPerformed(ActionEvent e)1375 protected void outputText_actionPerformed(ActionEvent e) 1376 { 1377 CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this); 1378 Frame frame = new Frame(); 1379 frame.add(cap); 1380 JalviewLite.addFrame(frame, MessageManager 1381 .formatMessage("label.alignment_output_command", new Object[] 1382 { e.getActionCommand() }), 600, 500); 1383 1384 FileFormatI fileFormat = FileFormats.getInstance() 1385 .forName(e.getActionCommand()); 1386 cap.setText( 1387 new AppletFormatAdapter(alignPanel).formatSequences(fileFormat, 1388 viewport.getAlignment(), viewport.getShowJVSuffix())); 1389 } 1390 loadAnnotations()1391 public void loadAnnotations() 1392 { 1393 CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this); 1394 cap.setText(MessageManager 1395 .getString("label.paste_features_annotations_Tcoffee_here")); 1396 cap.setAnnotationImport(); 1397 Frame frame = new Frame(); 1398 frame.add(cap); 1399 jalview.bin.JalviewLite.addFrame(frame, 1400 MessageManager.getString("action.paste_annotations"), 400, 300); 1401 1402 } 1403 outputAnnotations(boolean displayTextbox)1404 public String outputAnnotations(boolean displayTextbox) 1405 { 1406 String annotation = new AnnotationFile() 1407 .printAnnotationsForView(viewport); 1408 1409 if (displayTextbox) 1410 { 1411 CutAndPasteTransfer cap = new CutAndPasteTransfer(false, this); 1412 Frame frame = new Frame(); 1413 frame.add(cap); 1414 jalview.bin.JalviewLite.addFrame(frame, 1415 MessageManager.getString("label.annotations"), 600, 500); 1416 cap.setText(annotation); 1417 } 1418 1419 return annotation; 1420 } 1421 getDisplayedFeatureCols()1422 private Map<String, FeatureColourI> getDisplayedFeatureCols() 1423 { 1424 if (alignPanel.getFeatureRenderer() != null 1425 && viewport.getFeaturesDisplayed() != null) 1426 { 1427 return alignPanel.getFeatureRenderer().getDisplayedFeatureCols(); 1428 1429 } 1430 return null; 1431 } 1432 getDisplayedFeatureGroups()1433 private List<String> getDisplayedFeatureGroups() 1434 { 1435 if (alignPanel.getFeatureRenderer() != null 1436 && viewport.getFeaturesDisplayed() != null) 1437 { 1438 return alignPanel.getFeatureRenderer().getDisplayedFeatureGroups(); 1439 1440 } 1441 return null; 1442 } 1443 outputFeatures(boolean displayTextbox, String format)1444 public String outputFeatures(boolean displayTextbox, String format) 1445 { 1446 String features; 1447 FeaturesFile formatter = new FeaturesFile(); 1448 if (format.equalsIgnoreCase("Jalview")) 1449 { 1450 features = formatter.printJalviewFormat( 1451 viewport.getAlignment().getSequencesArray(), 1452 alignPanel.getFeatureRenderer(), true, false); 1453 } 1454 else 1455 { 1456 features = formatter.printGffFormat(viewport.getAlignment() 1457 .getSequencesArray(), alignPanel.getFeatureRenderer(), true, 1458 false); 1459 } 1460 1461 if (displayTextbox) 1462 { 1463 boolean frimport = false; 1464 if (features == null || features.equals("No Features Visible")) 1465 { 1466 features = "# No features visible - paste some and import them here."; 1467 frimport = true; 1468 } 1469 1470 CutAndPasteTransfer cap = new CutAndPasteTransfer(frimport, this); 1471 if (frimport) 1472 { 1473 cap.setAnnotationImport(); 1474 } 1475 Frame frame = new Frame(); 1476 frame.add(cap); 1477 jalview.bin.JalviewLite.addFrame(frame, 1478 MessageManager.getString("label.features"), 600, 500); 1479 cap.setText(features); 1480 } 1481 else 1482 { 1483 if (features == null) 1484 { 1485 features = ""; 1486 } 1487 } 1488 1489 return features; 1490 } 1491 launchFullApplication()1492 void launchFullApplication() 1493 { 1494 StringBuffer url = new StringBuffer(jalviewServletURL); 1495 1496 // allow servlet parameters to be passed in applet parameter 1497 String firstSep = url.lastIndexOf("?") > url.lastIndexOf("/") ? "&" 1498 : "?"; 1499 url.append(firstSep); 1500 1501 url.append( 1502 "open=" + appendProtocol(viewport.applet.getParameter("file"))); 1503 1504 if (viewport.applet.getParameter("features") != null) 1505 { 1506 url.append("&features="); 1507 url.append(appendProtocol(viewport.applet.getParameter("features"))); 1508 } 1509 1510 if (viewport.applet.getParameter("annotations") != null) 1511 { 1512 url.append("&annotations="); 1513 url.append( 1514 appendProtocol(viewport.applet.getParameter("annotations"))); 1515 } 1516 1517 if (viewport.applet.getParameter("jnetfile") != null 1518 || viewport.applet.getParameter("jpredfile") != null) 1519 { 1520 url.append("&annotations="); 1521 url.append(appendProtocol( 1522 viewport.applet.getParameter("jnetfile") != null 1523 ? viewport.applet.getParameter("jnetfile") 1524 : viewport.applet.getParameter("jpredfile"))); 1525 } 1526 1527 if (viewport.applet.getParameter("defaultColour") != null) 1528 { 1529 url.append("&colour=" + removeWhiteSpace( 1530 viewport.applet.getParameter("defaultColour"))); 1531 } 1532 1533 if (viewport.applet.getParameter("userDefinedColour") != null) 1534 { 1535 url.append("&colour=" + removeWhiteSpace( 1536 viewport.applet.getParameter("userDefinedColour"))); 1537 } 1538 if (viewport.applet.getParameter("tree") != null) 1539 { 1540 url.append("&tree=" 1541 + appendProtocol(viewport.applet.getParameter("tree"))); 1542 } 1543 if (viewport.applet.getParameter("treeFile") != null) 1544 { 1545 url.append("&tree=" 1546 + appendProtocol(viewport.applet.getParameter("treeFile"))); 1547 } 1548 1549 showURL(url.toString(), "FULL_APP"); 1550 } 1551 removeWhiteSpace(String colour)1552 String removeWhiteSpace(String colour) 1553 { 1554 StringBuffer sb = new StringBuffer(); 1555 for (int i = 0; i < colour.length(); i++) 1556 { 1557 if (Character.isWhitespace(colour.charAt(i))) 1558 { 1559 sb.append("%20"); 1560 } 1561 else 1562 { 1563 sb.append(colour.charAt(i)); 1564 } 1565 } 1566 1567 return sb.toString(); 1568 } 1569 appendProtocol(String url)1570 String appendProtocol(String url) 1571 { 1572 try 1573 { 1574 new URL(url); 1575 url = URLEncoder.encode(url, "UTF-8"); 1576 } 1577 /* 1578 * When we finally deprecate 1.1 compatibility, we can start to use 1579 * URLEncoder.encode(url,"UTF-8") and then we'll need this catch: catch 1580 * (UnsupportedEncodingException ex) { System.err.println("WARNING - 1581 * IMPLEMENTATION ERROR - UNSUPPORTED ENCODING EXCEPTION FOR "+url); 1582 * ex.printStackTrace(); } 1583 */ 1584 catch (java.net.MalformedURLException ex) 1585 { 1586 url = viewport.applet.getCodeBase() + url; 1587 } 1588 catch (UnsupportedEncodingException ex) 1589 { 1590 System.err.println( 1591 "WARNING = IMPLEMENTATION ERROR - UNSUPPORTED ENCODING EXCEPTION FOR " 1592 + url); 1593 ex.printStackTrace(); 1594 } 1595 return url; 1596 } 1597 closeMenuItem_actionPerformed()1598 public void closeMenuItem_actionPerformed() 1599 { 1600 PaintRefresher.RemoveComponent(alignPanel); 1601 if (alignPanel.seqPanel != null 1602 && alignPanel.seqPanel.seqCanvas != null) 1603 { 1604 PaintRefresher.RemoveComponent(alignPanel.seqPanel.seqCanvas); 1605 } 1606 if (alignPanel.idPanel != null && alignPanel.idPanel.idCanvas != null) 1607 { 1608 PaintRefresher.RemoveComponent(alignPanel.idPanel.idCanvas); 1609 } 1610 1611 if (PaintRefresher.components.size() == 0 && viewport.applet == null) 1612 { 1613 System.exit(0); 1614 } 1615 1616 viewport = null; 1617 if (alignPanel != null && alignPanel.overviewPanel != null) 1618 { 1619 alignPanel.overviewPanel.dispose(); 1620 } 1621 alignPanel = null; 1622 this.dispose(); 1623 } 1624 1625 /** 1626 * TODO: JAL-1104 1627 */ updateEditMenuBar()1628 void updateEditMenuBar() 1629 { 1630 1631 if (viewport.getHistoryList().size() > 0) 1632 { 1633 undoMenuItem.setEnabled(true); 1634 CommandI command = viewport.getHistoryList().peek(); 1635 undoMenuItem.setLabel(MessageManager 1636 .formatMessage("label.undo_command", new Object[] 1637 { command.getDescription() })); 1638 } 1639 else 1640 { 1641 undoMenuItem.setEnabled(false); 1642 undoMenuItem.setLabel(MessageManager.getString("action.undo")); 1643 } 1644 1645 if (viewport.getRedoList().size() > 0) 1646 { 1647 redoMenuItem.setEnabled(true); 1648 1649 CommandI command = viewport.getRedoList().peek(); 1650 redoMenuItem.setLabel(MessageManager 1651 .formatMessage("label.redo_command", new Object[] 1652 { command.getDescription() })); 1653 } 1654 else 1655 { 1656 redoMenuItem.setEnabled(false); 1657 redoMenuItem.setLabel(MessageManager.getString("action.redo")); 1658 } 1659 } 1660 1661 /** 1662 * TODO: JAL-1104 1663 */ 1664 @Override addHistoryItem(CommandI command)1665 public void addHistoryItem(CommandI command) 1666 { 1667 if (command.getSize() > 0) 1668 { 1669 viewport.addToHistoryList(command); 1670 viewport.clearRedoList(); 1671 updateEditMenuBar(); 1672 viewport.updateHiddenColumns(); 1673 } 1674 } 1675 1676 /** 1677 * TODO: JAL-1104 DOCUMENT ME! 1678 * 1679 * @param e 1680 * DOCUMENT ME! 1681 */ undoMenuItem_actionPerformed()1682 protected void undoMenuItem_actionPerformed() 1683 { 1684 if (viewport.getHistoryList().isEmpty()) 1685 { 1686 return; 1687 } 1688 1689 CommandI command = viewport.getHistoryList().pop(); 1690 viewport.addToRedoList(command); 1691 command.undoCommand(null); 1692 1693 AlignmentViewport originalSource = getOriginatingSource(command); 1694 // JBPNote Test 1695 if (originalSource != viewport) 1696 { 1697 System.err 1698 .println("Warning: Viewport object mismatch whilst undoing"); 1699 } 1700 originalSource.updateHiddenColumns(); // originalSource.hasHiddenColumns = 1701 // viewport.getColumnSelection().getHiddenColumns() 1702 // != null; 1703 updateEditMenuBar(); 1704 originalSource.firePropertyChange("alignment", null, 1705 originalSource.getAlignment().getSequences()); 1706 } 1707 1708 /** 1709 * TODO: JAL-1104 DOCUMENT ME! 1710 * 1711 * @param e 1712 * DOCUMENT ME! 1713 */ redoMenuItem_actionPerformed()1714 protected void redoMenuItem_actionPerformed() 1715 { 1716 if (viewport.getRedoList().isEmpty()) 1717 { 1718 return; 1719 } 1720 1721 CommandI command = viewport.getRedoList().pop(); 1722 viewport.addToHistoryList(command); 1723 command.doCommand(null); 1724 1725 AlignmentViewport originalSource = getOriginatingSource(command); 1726 // JBPNote Test 1727 if (originalSource != viewport) 1728 { 1729 System.err 1730 .println("Warning: Viewport object mismatch whilst re-doing"); 1731 } 1732 originalSource.updateHiddenColumns(); // sethasHiddenColumns(); = 1733 // viewport.getColumnSelection().getHiddenColumns() 1734 // != null; 1735 1736 updateEditMenuBar(); 1737 originalSource.firePropertyChange("alignment", null, 1738 originalSource.getAlignment().getSequences()); 1739 } 1740 getOriginatingSource(CommandI command)1741 AlignmentViewport getOriginatingSource(CommandI command) 1742 { 1743 AlignmentViewport originalSource = null; 1744 // For sequence removal and addition, we need to fire 1745 // the property change event FROM the viewport where the 1746 // original alignment was altered 1747 AlignmentI al = null; 1748 if (command instanceof EditCommand) 1749 { 1750 EditCommand editCommand = (EditCommand) command; 1751 al = editCommand.getAlignment(); 1752 Vector comps = PaintRefresher.components 1753 .get(viewport.getSequenceSetId()); 1754 for (int i = 0; i < comps.size(); i++) 1755 { 1756 if (comps.elementAt(i) instanceof AlignmentPanel) 1757 { 1758 if (al == ((AlignmentPanel) comps.elementAt(i)).av.getAlignment()) 1759 { 1760 originalSource = ((AlignmentPanel) comps.elementAt(i)).av; 1761 break; 1762 } 1763 } 1764 } 1765 } 1766 1767 if (originalSource == null) 1768 { 1769 // The original view is closed, we must validate 1770 // the current view against the closed view first 1771 if (al != null) 1772 { 1773 PaintRefresher.validateSequences(al, viewport.getAlignment()); 1774 } 1775 1776 originalSource = viewport; 1777 } 1778 1779 return originalSource; 1780 } 1781 1782 /** 1783 * Move the currently selected sequences up or down one position in the 1784 * alignment 1785 * 1786 * @param up 1787 */ moveSelectedSequences(boolean up)1788 public void moveSelectedSequences(boolean up) 1789 { 1790 SequenceGroup sg = viewport.getSelectionGroup(); 1791 if (sg == null) 1792 { 1793 return; 1794 } 1795 viewport.getAlignment().moveSelectedSequencesByOne(sg, 1796 up ? null : viewport.getHiddenRepSequences(), up); 1797 alignPanel.paintAlignment(true, false); 1798 1799 /* 1800 * Also move cDNA/protein complement sequences 1801 */ 1802 AlignViewportI complement = viewport.getCodingComplement(); 1803 if (complement != null) 1804 { 1805 SequenceGroup mappedSelection = MappingUtils.mapSequenceGroup(sg, 1806 viewport, complement); 1807 complement.getAlignment().moveSelectedSequencesByOne(mappedSelection, 1808 up ? null : complement.getHiddenRepSequences(), up); 1809 getSplitFrame().getComplement(this).alignPanel.paintAlignment(true, 1810 false); 1811 } 1812 } 1813 slideSequences(boolean right, int size)1814 synchronized void slideSequences(boolean right, int size) 1815 { 1816 List<SequenceI> sg = new Vector<>(); 1817 if (viewport.cursorMode) 1818 { 1819 sg.add(viewport.getAlignment() 1820 .getSequenceAt(alignPanel.seqPanel.seqCanvas.cursorY)); 1821 } 1822 else if (viewport.getSelectionGroup() != null 1823 && viewport.getSelectionGroup().getSize() != viewport 1824 .getAlignment().getHeight()) 1825 { 1826 sg = viewport.getSelectionGroup() 1827 .getSequences(viewport.getHiddenRepSequences()); 1828 } 1829 1830 if (sg.size() < 1) 1831 { 1832 return; 1833 } 1834 1835 Vector<SequenceI> invertGroup = new Vector(); 1836 1837 for (int i = 0; i < viewport.getAlignment().getHeight(); i++) 1838 { 1839 if (!sg.contains(viewport.getAlignment().getSequenceAt(i))) 1840 { 1841 invertGroup.addElement(viewport.getAlignment().getSequenceAt(i)); 1842 } 1843 } 1844 1845 SequenceI[] seqs1 = sg.toArray(new SequenceI[sg.size()]); 1846 1847 SequenceI[] seqs2 = invertGroup 1848 .toArray(new SequenceI[invertGroup.size()]); 1849 for (int i = 0; i < invertGroup.size(); i++) 1850 { 1851 seqs2[i] = invertGroup.elementAt(i); 1852 } 1853 1854 SlideSequencesCommand ssc; 1855 if (right) 1856 { 1857 ssc = new SlideSequencesCommand("Slide Sequences", seqs2, seqs1, size, 1858 viewport.getGapCharacter()); 1859 } 1860 else 1861 { 1862 ssc = new SlideSequencesCommand("Slide Sequences", seqs1, seqs2, size, 1863 viewport.getGapCharacter()); 1864 } 1865 1866 int groupAdjustment = 0; 1867 if (ssc.getGapsInsertedBegin() && right) 1868 { 1869 if (viewport.cursorMode) 1870 { 1871 alignPanel.seqPanel.moveCursor(size, 0); 1872 } 1873 else 1874 { 1875 groupAdjustment = size; 1876 } 1877 } 1878 else if (!ssc.getGapsInsertedBegin() && !right) 1879 { 1880 if (viewport.cursorMode) 1881 { 1882 alignPanel.seqPanel.moveCursor(-size, 0); 1883 } 1884 else 1885 { 1886 groupAdjustment = -size; 1887 } 1888 } 1889 1890 if (groupAdjustment != 0) 1891 { 1892 viewport.getSelectionGroup().setStartRes( 1893 viewport.getSelectionGroup().getStartRes() + groupAdjustment); 1894 viewport.getSelectionGroup().setEndRes( 1895 viewport.getSelectionGroup().getEndRes() + groupAdjustment); 1896 } 1897 1898 boolean appendHistoryItem = false; 1899 Deque<CommandI> historyList = viewport.getHistoryList(); 1900 if (historyList != null && historyList.size() > 0 1901 && historyList.peek() instanceof SlideSequencesCommand) 1902 { 1903 appendHistoryItem = ssc.appendSlideCommand( 1904 (SlideSequencesCommand) historyList.peek()); 1905 } 1906 1907 if (!appendHistoryItem) 1908 { 1909 addHistoryItem(ssc); 1910 } 1911 1912 repaint(); 1913 } 1914 1915 static StringBuffer copiedSequences; 1916 1917 static HiddenColumns copiedHiddenColumns; 1918 copy_actionPerformed()1919 protected void copy_actionPerformed() 1920 { 1921 if (viewport.getSelectionGroup() == null) 1922 { 1923 return; 1924 } 1925 1926 SequenceGroup sg = viewport.getSelectionGroup(); 1927 copiedSequences = new StringBuffer(); 1928 Map<Integer, SequenceI> orderedSeqs = new HashMap<>(); 1929 for (int i = 0; i < sg.getSize(); i++) 1930 { 1931 SequenceI seq = sg.getSequenceAt(i); 1932 int index = viewport.getAlignment().findIndex(seq); 1933 orderedSeqs.put(index, seq); 1934 } 1935 1936 int index = 0, startRes, endRes; 1937 char ch; 1938 1939 if (viewport.hasHiddenColumns() && viewport.getSelectionGroup() != null) 1940 { 1941 int hiddenOffset = viewport.getSelectionGroup().getStartRes(); 1942 int hiddenCutoff = viewport.getSelectionGroup().getEndRes(); 1943 1944 // create new HiddenColumns object with copy of hidden regions 1945 // between startRes and endRes, offset by startRes 1946 copiedHiddenColumns = new HiddenColumns( 1947 viewport.getAlignment().getHiddenColumns(), hiddenOffset, 1948 hiddenCutoff, hiddenOffset); 1949 } 1950 else 1951 { 1952 copiedHiddenColumns = null; 1953 } 1954 1955 for (int i = 0; i < sg.getSize(); i++) 1956 { 1957 SequenceI seq = null; 1958 1959 while (seq == null) 1960 { 1961 if (orderedSeqs.containsKey(index)) 1962 { 1963 seq = orderedSeqs.get(index); 1964 index++; 1965 break; 1966 } 1967 else 1968 { 1969 index++; 1970 } 1971 } 1972 1973 // FIND START RES 1974 // Returns residue following index if gap 1975 startRes = seq.findPosition(sg.getStartRes()); 1976 1977 // FIND END RES 1978 // Need to find the residue preceeding index if gap 1979 endRes = 0; 1980 1981 for (int j = 0; j < sg.getEndRes() + 1 && j < seq.getLength(); j++) 1982 { 1983 ch = seq.getCharAt(j); 1984 if (!jalview.util.Comparison.isGap((ch))) 1985 { 1986 endRes++; 1987 } 1988 } 1989 1990 if (endRes > 0) 1991 { 1992 endRes += seq.getStart() - 1; 1993 } 1994 1995 copiedSequences.append(seq.getName() + "\t" + startRes + "\t" + endRes 1996 + "\t" + seq.getSequenceAsString(sg.getStartRes(), 1997 sg.getEndRes() + 1) 1998 + "\n"); 1999 } 2000 2001 } 2002 pasteNew_actionPerformed()2003 protected void pasteNew_actionPerformed() 2004 { 2005 paste(true); 2006 } 2007 pasteThis_actionPerformed()2008 protected void pasteThis_actionPerformed() 2009 { 2010 paste(false); 2011 } 2012 paste(boolean newAlignment)2013 void paste(boolean newAlignment) 2014 { 2015 try 2016 { 2017 if (copiedSequences == null) 2018 { 2019 return; 2020 } 2021 2022 StringTokenizer st = new StringTokenizer(copiedSequences.toString(), 2023 "\t"); 2024 Vector seqs = new Vector(); 2025 while (st.hasMoreElements()) 2026 { 2027 String name = st.nextToken(); 2028 int start = Integer.parseInt(st.nextToken()); 2029 int end = Integer.parseInt(st.nextToken()); 2030 seqs.addElement(new Sequence(name, st.nextToken(), start, end)); 2031 } 2032 SequenceI[] newSeqs = new SequenceI[seqs.size()]; 2033 for (int i = 0; i < seqs.size(); i++) 2034 { 2035 newSeqs[i] = (SequenceI) seqs.elementAt(i); 2036 } 2037 2038 if (newAlignment) 2039 { 2040 String newtitle = MessageManager 2041 .getString("label.copied_sequences"); 2042 if (getTitle().startsWith( 2043 MessageManager.getString("label.copied_sequences"))) 2044 { 2045 newtitle = getTitle(); 2046 } 2047 else 2048 { 2049 newtitle = newtitle.concat(MessageManager 2050 .formatMessage("label.from_msname", new String[] 2051 { getTitle() })); 2052 } 2053 AlignFrame af = new AlignFrame(new Alignment(newSeqs), 2054 viewport.applet, newtitle, false); 2055 af.viewport.setHiddenColumns(copiedHiddenColumns); 2056 2057 jalview.bin.JalviewLite.addFrame(af, newtitle, frameWidth, 2058 frameHeight); 2059 } 2060 else 2061 { 2062 addSequences(newSeqs); 2063 } 2064 2065 } catch (Exception ex) 2066 { 2067 } // could be anything being pasted in here 2068 2069 } 2070 addSequences(SequenceI[] seqs)2071 void addSequences(SequenceI[] seqs) 2072 { 2073 for (int i = 0; i < seqs.length; i++) 2074 { 2075 viewport.getAlignment().addSequence(seqs[i]); 2076 } 2077 2078 // !newAlignment 2079 addHistoryItem(new EditCommand( 2080 MessageManager.getString("label.add_sequences"), Action.PASTE, 2081 seqs, 0, viewport.getAlignment().getWidth(), 2082 viewport.getAlignment())); 2083 2084 viewport.getRanges().setEndSeq(viewport.getAlignment().getHeight()); 2085 viewport.getAlignment().getWidth(); 2086 viewport.firePropertyChange("alignment", null, 2087 viewport.getAlignment().getSequences()); 2088 2089 } 2090 cut_actionPerformed()2091 protected void cut_actionPerformed() 2092 { 2093 copy_actionPerformed(); 2094 delete_actionPerformed(); 2095 } 2096 delete_actionPerformed()2097 protected void delete_actionPerformed() 2098 { 2099 2100 SequenceGroup sg = viewport.getSelectionGroup(); 2101 if (sg == null) 2102 { 2103 return; 2104 } 2105 2106 Vector seqs = new Vector(); 2107 SequenceI seq; 2108 for (int i = 0; i < sg.getSize(); i++) 2109 { 2110 seq = sg.getSequenceAt(i); 2111 seqs.addElement(seq); 2112 } 2113 2114 /* 2115 * If the cut affects all sequences, warn, remove highlighted columns 2116 */ 2117 if (sg.getSize() == viewport.getAlignment().getHeight()) 2118 { 2119 boolean isEntireAlignWidth = (((sg.getEndRes() - sg.getStartRes()) 2120 + 1) == viewport.getAlignment().getWidth()) ? true : false; 2121 if (isEntireAlignWidth) 2122 { 2123 String title = MessageManager.getString("label.delete_all"); 2124 Panel infoPanel = new Panel(); 2125 infoPanel.setLayout(new FlowLayout()); 2126 infoPanel.add( 2127 new Label(MessageManager.getString("warn.delete_all"))); 2128 2129 final JVDialog dialog = new JVDialog(this, title, true, 400, 200); 2130 dialog.setMainPanel(infoPanel); 2131 dialog.ok.setLabel(MessageManager.getString("action.ok")); 2132 dialog.cancel.setLabel(MessageManager.getString("action.cancel")); 2133 dialog.setVisible(true); 2134 2135 if (!dialog.accept) 2136 { 2137 return; 2138 } 2139 } 2140 viewport.getColumnSelection().removeElements(sg.getStartRes(), 2141 sg.getEndRes() + 1); 2142 } 2143 2144 SequenceI[] cut = new SequenceI[seqs.size()]; 2145 for (int i = 0; i < seqs.size(); i++) 2146 { 2147 cut[i] = (SequenceI) seqs.elementAt(i); 2148 } 2149 2150 /* 2151 * //ADD HISTORY ITEM 2152 */ 2153 addHistoryItem(new EditCommand( 2154 MessageManager.getString("label.cut_sequences"), Action.CUT, 2155 cut, sg.getStartRes(), sg.getEndRes() - sg.getStartRes() + 1, 2156 viewport.getAlignment())); 2157 2158 viewport.setSelectionGroup(null); 2159 viewport.getAlignment().deleteGroup(sg); 2160 2161 viewport.firePropertyChange("alignment", null, 2162 viewport.getAlignment().getSequences()); 2163 2164 if (viewport.getAlignment().getHeight() < 1) 2165 { 2166 this.setVisible(false); 2167 } 2168 viewport.sendSelection(); 2169 } 2170 2171 /** 2172 * group consensus toggled 2173 * 2174 */ showGroupConsensus_actionPerformed()2175 protected void showGroupConsensus_actionPerformed() 2176 { 2177 viewport.setShowGroupConsensus(showGroupConsensus.getState()); 2178 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState()); 2179 2180 } 2181 2182 /** 2183 * group conservation toggled. 2184 */ showGroupConservation_actionPerformed()2185 protected void showGroupConservation_actionPerformed() 2186 { 2187 viewport.setShowGroupConservation(showGroupConservation.getState()); 2188 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState()); 2189 } 2190 2191 /* 2192 * (non-Javadoc) 2193 * 2194 * @see 2195 * jalview.jbgui.GAlignFrame#showConsensusHistogram_actionPerformed(java.awt 2196 * .event.ActionEvent) 2197 */ showConsensusHistogram_actionPerformed()2198 protected void showConsensusHistogram_actionPerformed() 2199 { 2200 viewport.setShowConsensusHistogram(showConsensusHistogram.getState()); 2201 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState()); 2202 } 2203 2204 /* 2205 * (non-Javadoc) 2206 * 2207 * @see 2208 * jalview.jbgui.GAlignFrame#showConsensusProfile_actionPerformed(java.awt 2209 * .event.ActionEvent) 2210 */ showSequenceLogo_actionPerformed()2211 protected void showSequenceLogo_actionPerformed() 2212 { 2213 viewport.setShowSequenceLogo(showSequenceLogo.getState()); 2214 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState()); 2215 } 2216 normSequenceLogo_actionPerformed()2217 protected void normSequenceLogo_actionPerformed() 2218 { 2219 showSequenceLogo.setState(true); 2220 viewport.setShowSequenceLogo(true); 2221 viewport.setNormaliseSequenceLogo(normSequenceLogo.getState()); 2222 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState()); 2223 } 2224 applyAutoAnnotationSettings_actionPerformed()2225 protected void applyAutoAnnotationSettings_actionPerformed() 2226 { 2227 alignPanel.updateAnnotation(applyAutoAnnotationSettings.getState()); 2228 } 2229 makeGrpsFromSelection_actionPerformed()2230 protected void makeGrpsFromSelection_actionPerformed() 2231 { 2232 if (avc.makeGroupsFromSelection()) 2233 { 2234 PaintRefresher.Refresh(this, viewport.getSequenceSetId()); 2235 alignPanel.updateAnnotation(); 2236 alignPanel.paintAlignment(true, true); 2237 } 2238 } 2239 createGroup_actionPerformed()2240 protected void createGroup_actionPerformed() 2241 { 2242 avc.createGroup(); 2243 } 2244 unGroup_actionPerformed()2245 protected void unGroup_actionPerformed() 2246 { 2247 if (avc.unGroup()) 2248 { 2249 alignPanel.alignmentChanged(); 2250 } 2251 } 2252 deleteGroups_actionPerformed()2253 protected void deleteGroups_actionPerformed() 2254 { 2255 if (avc.deleteGroups()) 2256 { 2257 alignPanel.alignmentChanged(); 2258 } 2259 } 2260 selectAllSequenceMenuItem_actionPerformed()2261 public void selectAllSequenceMenuItem_actionPerformed() 2262 { 2263 SequenceGroup sg = new SequenceGroup(); 2264 for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++) 2265 { 2266 sg.addSequence(viewport.getAlignment().getSequenceAt(i), false); 2267 } 2268 sg.setEndRes(viewport.getAlignment().getWidth() - 1); 2269 viewport.setSelectionGroup(sg); 2270 // JAL-2034 - should delegate to 2271 // alignPanel to decide if overview needs 2272 // updating. 2273 alignPanel.paintAlignment(false, false); 2274 PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId()); 2275 viewport.sendSelection(); 2276 } 2277 deselectAllSequenceMenuItem_actionPerformed()2278 public void deselectAllSequenceMenuItem_actionPerformed() 2279 { 2280 if (viewport.cursorMode) 2281 { 2282 alignPanel.seqPanel.keyboardNo1 = null; 2283 alignPanel.seqPanel.keyboardNo2 = null; 2284 } 2285 viewport.setSelectionGroup(null); 2286 viewport.getColumnSelection().clear(); 2287 viewport.setSelectionGroup(null); 2288 alignPanel.idPanel.idCanvas.searchResults = null; 2289 alignPanel.seqPanel.seqCanvas.highlightSearchResults(null); 2290 // JAL-2034 - should delegate to 2291 // alignPanel to decide if overview needs 2292 // updating. 2293 alignPanel.paintAlignment(false, false); 2294 PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId()); 2295 viewport.sendSelection(); 2296 } 2297 invertSequenceMenuItem_actionPerformed()2298 public void invertSequenceMenuItem_actionPerformed() 2299 { 2300 SequenceGroup sg = viewport.getSelectionGroup(); 2301 for (int i = 0; i < viewport.getAlignment().getSequences().size(); i++) 2302 { 2303 sg.addOrRemove(viewport.getAlignment().getSequenceAt(i), false); 2304 } 2305 2306 PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId()); 2307 viewport.sendSelection(); 2308 } 2309 invertColSel_actionPerformed()2310 public void invertColSel_actionPerformed() 2311 { 2312 viewport.invertColumnSelection(); 2313 alignPanel.paintAlignment(true, false); 2314 PaintRefresher.Refresh(alignPanel, viewport.getSequenceSetId()); 2315 viewport.sendSelection(); 2316 } 2317 trimAlignment(boolean trimLeft)2318 void trimAlignment(boolean trimLeft) 2319 { 2320 AlignmentI al = viewport.getAlignment(); 2321 ViewportRanges ranges = viewport.getRanges(); 2322 ColumnSelection colSel = viewport.getColumnSelection(); 2323 int column; 2324 2325 if (!colSel.isEmpty()) 2326 { 2327 if (trimLeft) 2328 { 2329 column = colSel.getMin(); 2330 } 2331 else 2332 { 2333 column = colSel.getMax(); 2334 } 2335 2336 SequenceI[] seqs; 2337 if (viewport.getSelectionGroup() != null) 2338 { 2339 seqs = viewport.getSelectionGroup() 2340 .getSequencesAsArray(viewport.getHiddenRepSequences()); 2341 } 2342 else 2343 { 2344 seqs = al.getSequencesArray(); 2345 } 2346 2347 TrimRegionCommand trimRegion; 2348 if (trimLeft) 2349 { 2350 trimRegion = new TrimRegionCommand("Remove Left", true, seqs, 2351 column, al); 2352 ranges.setStartRes(0); 2353 } 2354 else 2355 { 2356 trimRegion = new TrimRegionCommand("Remove Right", false, seqs, 2357 column, al); 2358 } 2359 2360 statusBar.setText(MessageManager 2361 .formatMessage("label.removed_columns", new String[] 2362 { Integer.valueOf(trimRegion.getSize()).toString() })); 2363 addHistoryItem(trimRegion); 2364 2365 for (SequenceGroup sg : al.getGroups()) 2366 { 2367 if ((trimLeft && !sg.adjustForRemoveLeft(column)) 2368 || (!trimLeft && !sg.adjustForRemoveRight(column))) 2369 { 2370 al.deleteGroup(sg); 2371 } 2372 } 2373 2374 viewport.firePropertyChange("alignment", null, al.getSequences()); 2375 } 2376 } 2377 removeGappedColumnMenuItem_actionPerformed()2378 public void removeGappedColumnMenuItem_actionPerformed() 2379 { 2380 AlignmentI al = viewport.getAlignment(); 2381 ViewportRanges ranges = viewport.getRanges(); 2382 int start = 0; 2383 int end = ranges.getAbsoluteAlignmentWidth() - 1; 2384 2385 SequenceI[] seqs; 2386 if (viewport.getSelectionGroup() != null) 2387 { 2388 seqs = viewport.getSelectionGroup() 2389 .getSequencesAsArray(viewport.getHiddenRepSequences()); 2390 start = viewport.getSelectionGroup().getStartRes(); 2391 end = viewport.getSelectionGroup().getEndRes(); 2392 } 2393 else 2394 { 2395 seqs = viewport.getAlignment().getSequencesArray(); 2396 } 2397 2398 RemoveGapColCommand removeGapCols = new RemoveGapColCommand( 2399 "Remove Gapped Columns", seqs, start, end, 2400 viewport.getAlignment()); 2401 2402 addHistoryItem(removeGapCols); 2403 2404 statusBar.setText(MessageManager 2405 .formatMessage("label.removed_empty_columns", new String[] 2406 { Integer.valueOf(removeGapCols.getSize()).toString() })); 2407 2408 // This is to maintain viewport position on first residue 2409 // of first sequence 2410 SequenceI seq = al.getSequenceAt(0); 2411 int startRes = seq.findPosition(ranges.getStartRes()); 2412 // ShiftList shifts; 2413 // viewport.getAlignment().removeGaps(shifts=new ShiftList()); 2414 // edit.alColumnChanges=shifts.getInverse(); 2415 // if (viewport.hasHiddenColumns) 2416 // viewport.getColumnSelection().compensateForEdits(shifts); 2417 ranges.setStartRes(seq.findIndex(startRes) - 1); 2418 viewport.firePropertyChange("alignment", null, al.getSequences()); 2419 2420 } 2421 removeAllGapsMenuItem_actionPerformed()2422 public void removeAllGapsMenuItem_actionPerformed() 2423 { 2424 AlignmentI al = viewport.getAlignment(); 2425 ViewportRanges ranges = viewport.getRanges(); 2426 int start = 0; 2427 int end = ranges.getAbsoluteAlignmentWidth() - 1; 2428 2429 SequenceI[] seqs; 2430 if (viewport.getSelectionGroup() != null) 2431 { 2432 seqs = viewport.getSelectionGroup() 2433 .getSequencesAsArray(viewport.getHiddenRepSequences()); 2434 start = viewport.getSelectionGroup().getStartRes(); 2435 end = viewport.getSelectionGroup().getEndRes(); 2436 } 2437 else 2438 { 2439 seqs = viewport.getAlignment().getSequencesArray(); 2440 } 2441 2442 // This is to maintain viewport position on first residue 2443 // of first sequence 2444 SequenceI seq = al.getSequenceAt(0); 2445 int startRes = seq.findPosition(ranges.getStartRes()); 2446 2447 addHistoryItem( 2448 new RemoveGapsCommand("Remove Gaps", seqs, start, end, al)); 2449 2450 ranges.setStartRes(seq.findIndex(startRes) - 1); 2451 2452 viewport.firePropertyChange("alignment", null, al.getSequences()); 2453 2454 } 2455 findMenuItem_actionPerformed()2456 public void findMenuItem_actionPerformed() 2457 { 2458 new Finder(alignPanel); 2459 } 2460 2461 /** 2462 * create a new view derived from the current view 2463 * 2464 * @param viewtitle 2465 * @return frame for the new view 2466 */ newView(String viewtitle)2467 public AlignFrame newView(String viewtitle) 2468 { 2469 AlignmentI newal; 2470 if (viewport.hasHiddenRows()) 2471 { 2472 newal = new Alignment(viewport.getAlignment().getHiddenSequences() 2473 .getFullAlignment().getSequencesArray()); 2474 } 2475 else 2476 { 2477 newal = new Alignment(viewport.getAlignment().getSequencesArray()); 2478 } 2479 2480 if (viewport.getAlignment().getAlignmentAnnotation() != null) 2481 { 2482 for (int i = 0; i < viewport.getAlignment() 2483 .getAlignmentAnnotation().length; i++) 2484 { 2485 if (!viewport.getAlignment() 2486 .getAlignmentAnnotation()[i].autoCalculated) 2487 { 2488 newal.addAnnotation( 2489 viewport.getAlignment().getAlignmentAnnotation()[i]); 2490 } 2491 } 2492 } 2493 2494 AlignFrame newaf = new AlignFrame(newal, viewport.applet, "", false); 2495 2496 newaf.viewport.setSequenceSetId(alignPanel.av.getSequenceSetId()); 2497 PaintRefresher.Register(alignPanel, alignPanel.av.getSequenceSetId()); 2498 PaintRefresher.Register(newaf.alignPanel, 2499 newaf.alignPanel.av.getSequenceSetId()); 2500 2501 PaintRefresher.Register(newaf.alignPanel.idPanel.idCanvas, 2502 newaf.alignPanel.av.getSequenceSetId()); 2503 PaintRefresher.Register(newaf.alignPanel.seqPanel.seqCanvas, 2504 newaf.alignPanel.av.getSequenceSetId()); 2505 2506 Vector comps = PaintRefresher.components 2507 .get(viewport.getSequenceSetId()); 2508 int viewSize = -1; 2509 for (int i = 0; i < comps.size(); i++) 2510 { 2511 if (comps.elementAt(i) instanceof AlignmentPanel) 2512 { 2513 viewSize++; 2514 } 2515 } 2516 2517 String title = new String(this.getTitle()); 2518 if (viewtitle != null) 2519 { 2520 title = viewtitle + " ( " + title + ")"; 2521 } 2522 else 2523 { 2524 if (title.indexOf("(View") > -1) 2525 { 2526 title = title.substring(0, title.indexOf("(View")); 2527 } 2528 title += "(View " + viewSize + ")"; 2529 } 2530 2531 newaf.setTitle(title.toString()); 2532 2533 newaf.viewport.setHistoryList(viewport.getHistoryList()); 2534 newaf.viewport.setRedoList(viewport.getRedoList()); 2535 return newaf; 2536 } 2537 2538 /** 2539 * 2540 * @return list of feature groups on the view 2541 */ getFeatureGroups()2542 public String[] getFeatureGroups() 2543 { 2544 FeatureRenderer fr = null; 2545 if (alignPanel != null 2546 && (fr = alignPanel.getFeatureRenderer()) != null) 2547 { 2548 List<String> gps = fr.getFeatureGroups(); 2549 String[] _gps = gps.toArray(new String[gps.size()]); 2550 return _gps; 2551 } 2552 return null; 2553 } 2554 2555 /** 2556 * get sequence feature groups that are hidden or shown 2557 * 2558 * @param visible 2559 * true is visible 2560 * @return list 2561 */ getFeatureGroupsOfState(boolean visible)2562 public String[] getFeatureGroupsOfState(boolean visible) 2563 { 2564 FeatureRenderer fr = null; 2565 if (alignPanel != null 2566 && (fr = alignPanel.getFeatureRenderer()) != null) 2567 { 2568 List<String> gps = fr.getGroups(visible); 2569 String[] _gps = gps.toArray(new String[gps.size()]); 2570 return _gps; 2571 } 2572 return null; 2573 } 2574 2575 /** 2576 * Change the display state for the given feature groups 2577 * 2578 * @param groups 2579 * list of group strings 2580 * @param state 2581 * visible or invisible 2582 */ setFeatureGroupState(String[] groups, boolean state)2583 public void setFeatureGroupState(String[] groups, boolean state) 2584 { 2585 FeatureRenderer fr = null; 2586 this.sequenceFeatures.setState(true); 2587 viewport.setShowSequenceFeatures(true); 2588 if (alignPanel != null 2589 && (fr = alignPanel.getFeatureRenderer()) != null) 2590 { 2591 2592 fr.setGroupVisibility(Arrays.asList(groups), state); 2593 alignPanel.seqPanel.seqCanvas.repaint(); 2594 if (alignPanel.overviewPanel != null) 2595 { 2596 alignPanel.overviewPanel.updateOverviewImage(); 2597 } 2598 } 2599 } 2600 seqLimits_itemStateChanged()2601 public void seqLimits_itemStateChanged() 2602 { 2603 viewport.setShowJVSuffix(seqLimits.getState()); 2604 alignPanel.fontChanged(); 2605 alignPanel.paintAlignment(true, false); 2606 } 2607 colourTextMenuItem_actionPerformed()2608 protected void colourTextMenuItem_actionPerformed() 2609 { 2610 viewport.setColourText(colourTextMenuItem.getState()); 2611 alignPanel.paintAlignment(false, false); 2612 } 2613 displayNonconservedMenuItem_actionPerformed()2614 protected void displayNonconservedMenuItem_actionPerformed() 2615 { 2616 viewport.setShowUnconserved(displayNonconservedMenuItem.getState()); 2617 alignPanel.paintAlignment(false, false); 2618 } 2619 wrapMenuItem_actionPerformed()2620 protected void wrapMenuItem_actionPerformed() 2621 { 2622 viewport.setWrapAlignment(wrapMenuItem.getState()); 2623 alignPanel.setWrapAlignment(wrapMenuItem.getState()); 2624 scaleAbove.setEnabled(wrapMenuItem.getState()); 2625 scaleLeft.setEnabled(wrapMenuItem.getState()); 2626 scaleRight.setEnabled(wrapMenuItem.getState()); 2627 alignPanel.paintAlignment(true, false); 2628 } 2629 overviewMenuItem_actionPerformed()2630 public void overviewMenuItem_actionPerformed() 2631 { 2632 if (alignPanel.overviewPanel != null) 2633 { 2634 return; 2635 } 2636 2637 Frame frame = new Frame(); 2638 final OverviewPanel overview = new OverviewPanel(alignPanel); 2639 frame.add(overview); 2640 // +50 must allow for applet frame window 2641 jalview.bin.JalviewLite.addFrame(frame, MessageManager 2642 .formatMessage("label.overview_params", new String[] 2643 { this.getTitle() }), overview.getPreferredSize().width, 2644 overview.getPreferredSize().height + 50); 2645 2646 frame.pack(); 2647 final AlignmentPanel ap = alignPanel; 2648 frame.addWindowListener(new WindowAdapter() 2649 { 2650 @Override 2651 public void windowClosing(WindowEvent e) 2652 { 2653 overview.dispose(); 2654 if (ap != null) 2655 { 2656 ap.setOverviewPanel(null); 2657 } 2658 }; 2659 }); 2660 2661 alignPanel.setOverviewPanel(overview); 2662 2663 } 2664 2665 @Override changeColour(ColourSchemeI cs)2666 public void changeColour(ColourSchemeI cs) 2667 { 2668 viewport.setGlobalColourScheme(cs); 2669 2670 alignPanel.paintAlignment(true, true); 2671 } 2672 modifyPID_actionPerformed()2673 protected void modifyPID_actionPerformed() 2674 { 2675 if (viewport.getAbovePIDThreshold() 2676 && viewport.getGlobalColourScheme() != null) 2677 { 2678 SliderPanel.setPIDSliderSource(alignPanel, 2679 viewport.getResidueShading(), alignPanel.getViewName()); 2680 SliderPanel.showPIDSlider(); 2681 } 2682 } 2683 modifyConservation_actionPerformed()2684 protected void modifyConservation_actionPerformed() 2685 { 2686 if (viewport.getConservationSelected() 2687 && viewport.getGlobalColourScheme() != null) 2688 { 2689 SliderPanel.setConservationSlider(alignPanel, 2690 viewport.getResidueShading(), alignPanel.getViewName()); 2691 SliderPanel.showConservationSlider(); 2692 } 2693 } 2694 conservationMenuItem_actionPerformed()2695 protected void conservationMenuItem_actionPerformed() 2696 { 2697 boolean selected = conservationMenuItem.getState(); 2698 modifyConservation.setEnabled(selected); 2699 viewport.setConservationSelected(selected); 2700 viewport.getResidueShading().setConservationApplied(selected); 2701 2702 changeColour(viewport.getGlobalColourScheme()); 2703 2704 if (selected) 2705 { 2706 modifyConservation_actionPerformed(); 2707 } 2708 else 2709 { 2710 SliderPanel.hideConservationSlider(); 2711 } 2712 } 2713 abovePIDThreshold_actionPerformed()2714 public void abovePIDThreshold_actionPerformed() 2715 { 2716 boolean selected = abovePIDThreshold.getState(); 2717 modifyPID.setEnabled(selected); 2718 viewport.setAbovePIDThreshold(selected); 2719 if (!selected) 2720 { 2721 viewport.getResidueShading().setThreshold(0, 2722 viewport.isIgnoreGapsConsensus()); 2723 } 2724 2725 changeColour(viewport.getGlobalColourScheme()); 2726 2727 if (selected) 2728 { 2729 modifyPID_actionPerformed(); 2730 } 2731 else 2732 { 2733 SliderPanel.hidePIDSlider(); 2734 } 2735 } 2736 sortPairwiseMenuItem_actionPerformed()2737 public void sortPairwiseMenuItem_actionPerformed() 2738 { 2739 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray(); 2740 AlignmentSorter.sortByPID(viewport.getAlignment(), 2741 viewport.getAlignment().getSequenceAt(0)); 2742 2743 addHistoryItem(new OrderCommand("Pairwise Sort", oldOrder, 2744 viewport.getAlignment())); 2745 alignPanel.paintAlignment(true, false); 2746 } 2747 sortIDMenuItem_actionPerformed()2748 public void sortIDMenuItem_actionPerformed() 2749 { 2750 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray(); 2751 AlignmentSorter.sortByID(viewport.getAlignment()); 2752 addHistoryItem( 2753 new OrderCommand("ID Sort", oldOrder, viewport.getAlignment())); 2754 alignPanel.paintAlignment(true, false); 2755 } 2756 sortLengthMenuItem_actionPerformed()2757 public void sortLengthMenuItem_actionPerformed() 2758 { 2759 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray(); 2760 AlignmentSorter.sortByLength(viewport.getAlignment()); 2761 addHistoryItem(new OrderCommand("Length Sort", oldOrder, 2762 viewport.getAlignment())); 2763 alignPanel.paintAlignment(true, false); 2764 } 2765 sortGroupMenuItem_actionPerformed()2766 public void sortGroupMenuItem_actionPerformed() 2767 { 2768 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray(); 2769 AlignmentSorter.sortByGroup(viewport.getAlignment()); 2770 addHistoryItem(new OrderCommand("Group Sort", oldOrder, 2771 viewport.getAlignment())); 2772 alignPanel.paintAlignment(true, false); 2773 2774 } 2775 removeRedundancyMenuItem_actionPerformed()2776 public void removeRedundancyMenuItem_actionPerformed() 2777 { 2778 new RedundancyPanel(alignPanel); 2779 } 2780 pairwiseAlignmentMenuItem_actionPerformed()2781 public void pairwiseAlignmentMenuItem_actionPerformed() 2782 { 2783 if (viewport.getSelectionGroup() != null 2784 && viewport.getSelectionGroup().getSize() > 1) 2785 { 2786 Frame frame = new Frame(); 2787 frame.add(new PairwiseAlignPanel(alignPanel)); 2788 jalview.bin.JalviewLite.addFrame(frame, 2789 MessageManager.getString("action.pairwise_alignment"), 600, 2790 500); 2791 } 2792 } 2793 PCAMenuItem_actionPerformed()2794 public void PCAMenuItem_actionPerformed() 2795 { 2796 // are the sequences aligned? 2797 if (!viewport.getAlignment().isAligned(false)) 2798 { 2799 SequenceI current; 2800 int Width = viewport.getAlignment().getWidth(); 2801 2802 for (int i = 0; i < viewport.getAlignment().getSequences() 2803 .size(); i++) 2804 { 2805 current = viewport.getAlignment().getSequenceAt(i); 2806 2807 if (current.getLength() < Width) 2808 { 2809 current.insertCharAt(Width - 1, viewport.getGapCharacter()); 2810 } 2811 } 2812 alignPanel.paintAlignment(false, false); 2813 } 2814 2815 if ((viewport.getSelectionGroup() != null 2816 && viewport.getSelectionGroup().getSize() < 4 2817 && viewport.getSelectionGroup().getSize() > 0) 2818 || viewport.getAlignment().getHeight() < 4) 2819 { 2820 return; 2821 } 2822 2823 try 2824 { 2825 new PCAPanel(viewport); 2826 } catch (java.lang.OutOfMemoryError ex) 2827 { 2828 } 2829 2830 } 2831 averageDistanceTreeMenuItem_actionPerformed()2832 public void averageDistanceTreeMenuItem_actionPerformed() 2833 { 2834 newTreePanel(TreeBuilder.AVERAGE_DISTANCE, new PIDModel().getName(), 2835 "Average distance tree using PID"); 2836 } 2837 neighbourTreeMenuItem_actionPerformed()2838 public void neighbourTreeMenuItem_actionPerformed() 2839 { 2840 newTreePanel(TreeBuilder.NEIGHBOUR_JOINING, new PIDModel().getName(), 2841 "Neighbour joining tree using PID"); 2842 } 2843 njTreeBlosumMenuItem_actionPerformed()2844 protected void njTreeBlosumMenuItem_actionPerformed() 2845 { 2846 newTreePanel(TreeBuilder.NEIGHBOUR_JOINING, 2847 ScoreModels.getInstance().getBlosum62().getName(), 2848 "Neighbour joining tree using BLOSUM62"); 2849 } 2850 avTreeBlosumMenuItem_actionPerformed()2851 protected void avTreeBlosumMenuItem_actionPerformed() 2852 { 2853 newTreePanel(TreeBuilder.AVERAGE_DISTANCE, 2854 ScoreModels.getInstance().getBlosum62().getName(), 2855 "Average distance tree using BLOSUM62"); 2856 } 2857 newTreePanel(String type, String pwType, String title)2858 void newTreePanel(String type, String pwType, String title) 2859 { 2860 // are the sequences aligned? 2861 if (!viewport.getAlignment().isAligned(false)) 2862 { 2863 SequenceI current; 2864 int Width = viewport.getAlignment().getWidth(); 2865 2866 for (int i = 0; i < viewport.getAlignment().getSequences() 2867 .size(); i++) 2868 { 2869 current = viewport.getAlignment().getSequenceAt(i); 2870 2871 if (current.getLength() < Width) 2872 { 2873 current.insertCharAt(Width - 1, viewport.getGapCharacter()); 2874 } 2875 } 2876 alignPanel.paintAlignment(false, false); 2877 2878 } 2879 2880 if ((viewport.getSelectionGroup() != null 2881 && viewport.getSelectionGroup().getSize() > 1) 2882 || (viewport.getAlignment().getHeight() > 1)) 2883 { 2884 final TreePanel tp = new TreePanel(alignPanel, type, pwType); 2885 2886 addTreeMenuItem(tp, title); 2887 2888 jalview.bin.JalviewLite.addFrame(tp, title, 600, 500); 2889 } 2890 } 2891 loadTree_actionPerformed()2892 void loadTree_actionPerformed() 2893 { 2894 CutAndPasteTransfer cap = new CutAndPasteTransfer(true, this); 2895 cap.setText(MessageManager.getString("label.paste_newick_tree_file")); 2896 cap.setTreeImport(); 2897 Frame frame = new Frame(); 2898 frame.add(cap); 2899 jalview.bin.JalviewLite.addFrame(frame, 2900 MessageManager.getString("label.paste_newick_file"), 400, 300); 2901 } 2902 loadTree(jalview.io.NewickFile tree, String treeFile)2903 public void loadTree(jalview.io.NewickFile tree, String treeFile) 2904 { 2905 TreePanel tp = new TreePanel(alignPanel, treeFile, 2906 MessageManager.getString("label.load_tree_from_file"), tree); 2907 jalview.bin.JalviewLite.addFrame(tp, treeFile, 600, 500); 2908 addTreeMenuItem(tp, treeFile); 2909 } 2910 2911 /** 2912 * sort the alignment using the given treePanel 2913 * 2914 * @param treePanel 2915 * tree used to sort view 2916 * @param title 2917 * string used for undo event name 2918 */ sortByTree(TreePanel treePanel, String title)2919 public void sortByTree(TreePanel treePanel, String title) 2920 { 2921 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray(); 2922 AlignmentSorter.sortByTree(viewport.getAlignment(), 2923 treePanel.getTree()); 2924 // addHistoryItem(new HistoryItem("Sort", viewport.alignment, 2925 // HistoryItem.SORT)); 2926 addHistoryItem(new OrderCommand(MessageManager 2927 .formatMessage("label.order_by_params", new String[] 2928 { title }), oldOrder, viewport.getAlignment())); 2929 alignPanel.paintAlignment(true, false); 2930 } 2931 2932 /** 2933 * Do any automatic reordering of the alignment and add the necessary bits to 2934 * the menu structure for the new tree 2935 * 2936 * @param treePanel 2937 * @param title 2938 */ addTreeMenuItem(final TreePanel treePanel, final String title)2939 protected void addTreeMenuItem(final TreePanel treePanel, 2940 final String title) 2941 { 2942 final MenuItem item = new MenuItem(title); 2943 sortByTreeMenu.add(item); 2944 item.addActionListener(new java.awt.event.ActionListener() 2945 { 2946 @Override 2947 public void actionPerformed(ActionEvent evt) 2948 { 2949 sortByTree(treePanel, title); // treePanel.getTitle()); 2950 } 2951 }); 2952 2953 treePanel.addWindowListener(new WindowAdapter() 2954 { 2955 @Override 2956 public void windowOpened(WindowEvent e) 2957 { 2958 if (viewport.sortByTree) 2959 { 2960 sortByTree(treePanel, title); 2961 } 2962 super.windowOpened(e); 2963 } 2964 2965 @Override 2966 public void windowClosing(WindowEvent e) 2967 { 2968 sortByTreeMenu.remove(item); 2969 }; 2970 }); 2971 } 2972 sortBy(AlignmentOrder alorder, String undoname)2973 public boolean sortBy(AlignmentOrder alorder, String undoname) 2974 { 2975 SequenceI[] oldOrder = viewport.getAlignment().getSequencesArray(); 2976 if (viewport.applet.debug) 2977 { 2978 System.err.println("Sorting " + alorder.getOrder().size() 2979 + " in alignment '" + getTitle() + "'"); 2980 } 2981 AlignmentSorter.sortBy(viewport.getAlignment(), alorder); 2982 if (undoname != null) 2983 { 2984 addHistoryItem(new OrderCommand(undoname, oldOrder, 2985 viewport.getAlignment())); 2986 } 2987 alignPanel.paintAlignment(true, false); 2988 return true; 2989 } 2990 documentation_actionPerformed()2991 protected void documentation_actionPerformed() 2992 { 2993 alignPanel.av.applet.openJalviewHelpUrl(); 2994 } 2995 about_actionPerformed()2996 protected void about_actionPerformed() 2997 { 2998 2999 class AboutPanel extends Canvas 3000 { 3001 String version; 3002 3003 String builddate; 3004 3005 public AboutPanel(String version, String builddate) 3006 { 3007 this.version = version; 3008 this.builddate = builddate; 3009 } 3010 3011 @Override 3012 public void paint(Graphics g) 3013 { 3014 g.setColor(Color.white); 3015 g.fillRect(0, 0, getSize().width, getSize().height); 3016 g.setFont(new Font("Helvetica", Font.PLAIN, 12)); 3017 FontMetrics fm = g.getFontMetrics(); 3018 int fh = fm.getHeight(); 3019 int y = 5, x = 7; 3020 g.setColor(Color.black); 3021 // TODO: update this text for each release or centrally store it for 3022 // lite and application 3023 g.setFont(new Font("Helvetica", Font.BOLD, 14)); 3024 g.drawString(MessageManager 3025 .formatMessage("label.jalviewLite_release", new String[] 3026 { version }), x, y += fh); 3027 g.setFont(new Font("Helvetica", Font.BOLD, 12)); 3028 g.drawString(MessageManager.formatMessage("label.jaview_build_date", 3029 new String[] 3030 { builddate }), x, y += fh); 3031 g.setFont(new Font("Helvetica", Font.PLAIN, 12)); 3032 g.drawString(MessageManager.getString("label.jalview_authors_1"), x, 3033 y += fh * 1.5); 3034 g.drawString(MessageManager.getString("label.jalview_authors_2"), 3035 x + 50, y += fh + 8); 3036 g.drawString(MessageManager.getString("label.jalview_dev_managers"), 3037 x, y += fh); 3038 g.drawString(MessageManager 3039 .getString("label.jalview_distribution_lists"), x, y += fh); 3040 g.drawString(MessageManager.getString("label.jalview_please_cite"), 3041 x, y += fh + 8); 3042 g.drawString( 3043 MessageManager.getString("label.jalview_cite_1_authors"), x, 3044 y += fh); 3045 g.drawString(MessageManager.getString("label.jalview_cite_1_title"), 3046 x, y += fh); 3047 g.drawString(MessageManager.getString("label.jalview_cite_1_ref"), 3048 x, y += fh); 3049 } 3050 } 3051 3052 Frame frame = new Frame(); 3053 frame.add(new AboutPanel(JalviewLite.getVersion(), 3054 JalviewLite.getBuildDate())); 3055 jalview.bin.JalviewLite.addFrame(frame, 3056 MessageManager.getString("label.jalview"), 580, 220); 3057 3058 } 3059 showURL(String url, String target)3060 public void showURL(String url, String target) 3061 { 3062 if (viewport.applet == null) 3063 { 3064 System.out.println("Not running as applet - no browser available."); 3065 } 3066 else 3067 { 3068 viewport.applet.showURL(url, target); 3069 } 3070 } 3071 3072 // //////////////////////////////////////////////////////////////////////////////// 3073 // JBuilder Graphics here 3074 3075 MenuBar alignFrameMenuBar = new MenuBar(); 3076 3077 Menu fileMenu = new Menu(MessageManager.getString("action.file")); 3078 3079 MenuItem loadApplication = new MenuItem( 3080 MessageManager.getString("label.view_full_application")); 3081 3082 MenuItem loadTree = new MenuItem( 3083 MessageManager.getString("label.load_associated_tree")); 3084 3085 MenuItem loadAnnotations = new MenuItem( 3086 MessageManager.getString("label.load_features_annotations")); 3087 3088 MenuItem outputFeatures = new MenuItem( 3089 MessageManager.getString("label.export_features")); 3090 3091 MenuItem outputAnnotations = new MenuItem( 3092 MessageManager.getString("label.export_annotations")); 3093 3094 MenuItem closeMenuItem = new MenuItem( 3095 MessageManager.getString("action.close")); 3096 3097 MenuItem selectAllSequenceMenuItem = new MenuItem( 3098 MessageManager.getString("action.select_all")); 3099 3100 MenuItem deselectAllSequenceMenuItem = new MenuItem( 3101 MessageManager.getString("action.deselect_all")); 3102 3103 MenuItem invertSequenceMenuItem = new MenuItem( 3104 MessageManager.getString("action.invert_selection")); 3105 3106 MenuItem remove2LeftMenuItem = new MenuItem(); 3107 3108 MenuItem remove2RightMenuItem = new MenuItem(); 3109 3110 MenuItem removeGappedColumnMenuItem = new MenuItem(); 3111 3112 MenuItem removeAllGapsMenuItem = new MenuItem(); 3113 3114 CheckboxMenuItem viewBoxesMenuItem = new CheckboxMenuItem(); 3115 3116 CheckboxMenuItem viewTextMenuItem = new CheckboxMenuItem(); 3117 3118 MenuItem sortPairwiseMenuItem = new MenuItem(); 3119 3120 MenuItem sortIDMenuItem = new MenuItem(); 3121 3122 MenuItem sortLengthMenuItem = new MenuItem(); 3123 3124 MenuItem sortGroupMenuItem = new MenuItem(); 3125 3126 MenuItem removeRedundancyMenuItem = new MenuItem(); 3127 3128 MenuItem pairwiseAlignmentMenuItem = new MenuItem(); 3129 3130 MenuItem PCAMenuItem = new MenuItem(); 3131 3132 MenuItem averageDistanceTreeMenuItem = new MenuItem(); 3133 3134 MenuItem neighbourTreeMenuItem = new MenuItem(); 3135 3136 BorderLayout borderLayout1 = new BorderLayout(); 3137 3138 public Label statusBar = new Label(); 3139 3140 MenuItem clustalColour = new MenuItem(); 3141 3142 MenuItem zappoColour = new MenuItem(); 3143 3144 MenuItem taylorColour = new MenuItem(); 3145 3146 MenuItem hydrophobicityColour = new MenuItem(); 3147 3148 MenuItem helixColour = new MenuItem(); 3149 3150 MenuItem strandColour = new MenuItem(); 3151 3152 MenuItem turnColour = new MenuItem(); 3153 3154 MenuItem buriedColour = new MenuItem(); 3155 3156 MenuItem purinePyrimidineColour = new MenuItem(); 3157 3158 // MenuItem RNAInteractionColour = new MenuItem(); 3159 3160 MenuItem RNAHelixColour = new MenuItem(); 3161 3162 MenuItem userDefinedColour = new MenuItem(); 3163 3164 MenuItem PIDColour = new MenuItem(); 3165 3166 MenuItem BLOSUM62Colour = new MenuItem(); 3167 3168 MenuItem tcoffeeColour = new MenuItem(); 3169 3170 MenuItem njTreeBlosumMenuItem = new MenuItem(); 3171 3172 MenuItem avDistanceTreeBlosumMenuItem = new MenuItem(); 3173 3174 CheckboxMenuItem annotationPanelMenuItem = new CheckboxMenuItem(); 3175 3176 CheckboxMenuItem colourTextMenuItem = new CheckboxMenuItem(); 3177 3178 CheckboxMenuItem displayNonconservedMenuItem = new CheckboxMenuItem(); 3179 3180 MenuItem alProperties = new MenuItem( 3181 MessageManager.getString("label.alignment_props")); 3182 3183 MenuItem overviewMenuItem = new MenuItem(); 3184 3185 MenuItem undoMenuItem = new MenuItem(); 3186 3187 MenuItem redoMenuItem = new MenuItem(); 3188 3189 CheckboxMenuItem conservationMenuItem = new CheckboxMenuItem(); 3190 3191 MenuItem noColourmenuItem = new MenuItem(); 3192 3193 CheckboxMenuItem wrapMenuItem = new CheckboxMenuItem(); 3194 3195 CheckboxMenuItem renderGapsMenuItem = new CheckboxMenuItem(); 3196 3197 MenuItem findMenuItem = new MenuItem(); 3198 3199 CheckboxMenuItem abovePIDThreshold = new CheckboxMenuItem(); 3200 3201 MenuItem nucleotideColour = new MenuItem(); 3202 3203 MenuItem deleteGroups = new MenuItem(); 3204 3205 MenuItem grpsFromSelection = new MenuItem(); 3206 3207 MenuItem createGroup = new MenuItem(); 3208 3209 MenuItem unGroup = new MenuItem(); 3210 3211 MenuItem delete = new MenuItem(); 3212 3213 MenuItem copy = new MenuItem(); 3214 3215 MenuItem cut = new MenuItem(); 3216 3217 Menu pasteMenu = new Menu(); 3218 3219 MenuItem pasteNew = new MenuItem(); 3220 3221 MenuItem pasteThis = new MenuItem(); 3222 3223 CheckboxMenuItem applyToAllGroups = new CheckboxMenuItem(); 3224 3225 MenuItem font = new MenuItem(); 3226 3227 CheckboxMenuItem scaleAbove = new CheckboxMenuItem(); 3228 3229 CheckboxMenuItem scaleLeft = new CheckboxMenuItem(); 3230 3231 CheckboxMenuItem scaleRight = new CheckboxMenuItem(); 3232 3233 MenuItem modifyPID = new MenuItem(); 3234 3235 MenuItem modifyConservation = new MenuItem(); 3236 3237 CheckboxMenuItem autoCalculate = null; 3238 3239 CheckboxMenuItem sortByTree = new CheckboxMenuItem( 3240 "Sort Alignment With New Tree", true); 3241 3242 Menu sortByTreeMenu = new Menu(); 3243 3244 MenuItem inputText = new MenuItem(); 3245 3246 MenuItem documentation = new MenuItem(); 3247 3248 MenuItem about = new MenuItem(); 3249 3250 CheckboxMenuItem seqLimits = new CheckboxMenuItem(); 3251 3252 CheckboxMenuItem centreColumnLabelFlag = new CheckboxMenuItem(); 3253 3254 CheckboxMenuItem followMouseOverFlag = new CheckboxMenuItem(); 3255 3256 CheckboxMenuItem showSequenceLogo = new CheckboxMenuItem(); 3257 3258 CheckboxMenuItem applyAutoAnnotationSettings = new CheckboxMenuItem(); 3259 3260 CheckboxMenuItem showConsensusHistogram = new CheckboxMenuItem(); 3261 3262 CheckboxMenuItem showGroupConsensus = new CheckboxMenuItem(); 3263 3264 CheckboxMenuItem showGroupConservation = new CheckboxMenuItem(); 3265 3266 CheckboxMenuItem normSequenceLogo = new CheckboxMenuItem(); 3267 3268 /** 3269 * Initialise menus and other items 3270 * 3271 * @throws Exception 3272 */ jbInit()3273 private void jbInit() throws Exception 3274 { 3275 setMenuBar(alignFrameMenuBar); 3276 3277 /* 3278 * Configure File menu items and actions 3279 */ 3280 inputText 3281 .setLabel(MessageManager.getString("label.input_from_textbox")); 3282 inputText.addActionListener(this); 3283 Menu outputTextboxMenu = new Menu( 3284 MessageManager.getString("label.out_to_textbox")); 3285 for (String ff : FileFormats.getInstance().getWritableFormats(true)) 3286 { 3287 MenuItem item = new MenuItem(ff); 3288 3289 item.addActionListener(new java.awt.event.ActionListener() 3290 { 3291 @Override 3292 public void actionPerformed(ActionEvent e) 3293 { 3294 outputText_actionPerformed(e); 3295 } 3296 }); 3297 3298 outputTextboxMenu.add(item); 3299 } 3300 closeMenuItem.addActionListener(this); 3301 loadApplication.addActionListener(this); 3302 loadTree.addActionListener(this); 3303 loadAnnotations.addActionListener(this); 3304 outputFeatures.addActionListener(this); 3305 outputAnnotations.addActionListener(this); 3306 3307 /* 3308 * Configure Edit menu items and actions 3309 */ 3310 undoMenuItem.setEnabled(false); 3311 undoMenuItem.setLabel(MessageManager.getString("action.undo")); 3312 undoMenuItem.addActionListener(this); 3313 redoMenuItem.setEnabled(false); 3314 redoMenuItem.setLabel(MessageManager.getString("action.redo")); 3315 redoMenuItem.addActionListener(this); 3316 copy.setLabel(MessageManager.getString("action.copy")); 3317 copy.addActionListener(this); 3318 cut.setLabel(MessageManager.getString("action.cut")); 3319 cut.addActionListener(this); 3320 delete.setLabel(MessageManager.getString("action.delete")); 3321 delete.addActionListener(this); 3322 pasteMenu.setLabel(MessageManager.getString("action.paste")); 3323 pasteNew.setLabel(MessageManager.getString("label.to_new_alignment")); 3324 pasteNew.addActionListener(this); 3325 pasteThis.setLabel(MessageManager.getString("label.to_this_alignment")); 3326 pasteThis.addActionListener(this); 3327 remove2LeftMenuItem 3328 .setLabel(MessageManager.getString("action.remove_left")); 3329 remove2LeftMenuItem.addActionListener(this); 3330 remove2RightMenuItem 3331 .setLabel(MessageManager.getString("action.remove_right")); 3332 remove2RightMenuItem.addActionListener(this); 3333 removeGappedColumnMenuItem.setLabel( 3334 MessageManager.getString("action.remove_empty_columns")); 3335 removeGappedColumnMenuItem.addActionListener(this); 3336 removeAllGapsMenuItem 3337 .setLabel(MessageManager.getString("action.remove_all_gaps")); 3338 removeAllGapsMenuItem.addActionListener(this); 3339 removeRedundancyMenuItem 3340 .setLabel(MessageManager.getString("action.remove_redundancy")); 3341 removeRedundancyMenuItem.addActionListener(this); 3342 3343 /* 3344 * Configure Select menu items and actions 3345 */ 3346 findMenuItem.setLabel(MessageManager.getString("action.find")); 3347 findMenuItem.addActionListener(this); 3348 selectAllSequenceMenuItem.addActionListener(this); 3349 deselectAllSequenceMenuItem.addActionListener(this); 3350 invertSequenceMenuItem.setLabel( 3351 MessageManager.getString("action.invert_sequence_selection")); 3352 invertSequenceMenuItem.addActionListener(this); 3353 invertColSel.setLabel( 3354 MessageManager.getString("action.invert_column_selection")); 3355 invertColSel.addActionListener(this); 3356 deleteGroups 3357 .setLabel(MessageManager.getString("action.undefine_groups")); 3358 deleteGroups.addActionListener(this); 3359 grpsFromSelection.setLabel( 3360 MessageManager.getString("action.make_groups_selection")); 3361 grpsFromSelection.addActionListener(this); 3362 createGroup.setLabel(MessageManager.getString("action.create_group")); 3363 createGroup.addActionListener(this); 3364 unGroup.setLabel(MessageManager.getString("action.remove_group")); 3365 unGroup.addActionListener(this); 3366 3367 annotationColumnSelection.setLabel( 3368 MessageManager.getString("action.select_by_annotation")); 3369 annotationColumnSelection.addActionListener(this); 3370 3371 /* 3372 * Configure View menu items and actions 3373 */ 3374 newView.setLabel(MessageManager.getString("action.new_view")); 3375 newView.addActionListener(this); 3376 Menu showMenu = new Menu(MessageManager.getString("action.show")); 3377 showColumns.setLabel(MessageManager.getString("label.all_columns")); 3378 showSeqs.setLabel(MessageManager.getString("label.all_sequences")); 3379 Menu hideMenu = new Menu(MessageManager.getString("action.hide")); 3380 hideColumns 3381 .setLabel(MessageManager.getString("label.selected_columns")); 3382 hideSequences 3383 .setLabel(MessageManager.getString("label.selected_sequences")); 3384 hideAllButSelection.setLabel( 3385 MessageManager.getString("label.all_but_selected_region")); 3386 hideAllSelection 3387 .setLabel(MessageManager.getString("label.selected_region")); 3388 showAllHidden.setLabel( 3389 MessageManager.getString("label.all_sequences_columns")); 3390 showColumns.addActionListener(this); 3391 showSeqs.addActionListener(this); 3392 hideColumns.addActionListener(this); 3393 hideSequences.addActionListener(this); 3394 hideAllButSelection.addActionListener(this); 3395 hideAllSelection.addActionListener(this); 3396 showAllHidden.addActionListener(this); 3397 featureSettings 3398 .setLabel(MessageManager.getString("action.feature_settings")); 3399 featureSettings.addActionListener(this); 3400 sequenceFeatures.setLabel( 3401 MessageManager.getString("label.show_sequence_features")); 3402 sequenceFeatures.addItemListener(this); 3403 sequenceFeatures.setState(false); 3404 followMouseOverFlag.setLabel( 3405 MessageManager.getString("label.automatic_scrolling")); 3406 followMouseOverFlag.addItemListener(this); 3407 alProperties.addActionListener(this); 3408 overviewMenuItem 3409 .setLabel(MessageManager.getString("label.overview_window")); 3410 overviewMenuItem.addActionListener(this); 3411 3412 /* 3413 * Configure Annotations menu items and actions 3414 */ 3415 annotationPanelMenuItem 3416 .setLabel(MessageManager.getString("label.show_annotations")); 3417 annotationPanelMenuItem.addItemListener(this); 3418 showGroupConsensus 3419 .setLabel(MessageManager.getString("label.group_consensus")); 3420 showGroupConservation 3421 .setLabel(MessageManager.getString("label.group_conservation")); 3422 showConsensusHistogram.setLabel( 3423 MessageManager.getString("label.show_consensus_histogram")); 3424 showSequenceLogo.setLabel( 3425 MessageManager.getString("label.show_consensus_logo")); 3426 normSequenceLogo.setLabel( 3427 MessageManager.getString("label.norm_consensus_logo")); 3428 applyAutoAnnotationSettings 3429 .setLabel(MessageManager.getString("label.apply_all_groups")); 3430 applyAutoAnnotationSettings.setState(true); 3431 Menu autoAnnMenu = new Menu( 3432 MessageManager.getString("label.autocalculated_annotation")); 3433 showGroupConsensus.addItemListener(this); 3434 showGroupConservation.addItemListener(this); 3435 showConsensusHistogram.addItemListener(this); 3436 showSequenceLogo.addItemListener(this); 3437 normSequenceLogo.addItemListener(this); 3438 applyAutoAnnotationSettings.addItemListener(this); 3439 showAlignmentAnnotations = new CheckboxMenuItem( 3440 MessageManager.getString("label.show_all_al_annotations")); 3441 showSequenceAnnotations = new CheckboxMenuItem( 3442 MessageManager.getString("label.show_all_seq_annotations")); 3443 sortAnnBySequence = new CheckboxMenuItem( 3444 MessageManager.getString("label.sort_annotations_by_sequence")); 3445 sortAnnByLabel = new CheckboxMenuItem( 3446 MessageManager.getString("label.sort_annotations_by_label")); 3447 showAutoFirst = new CheckboxMenuItem( 3448 MessageManager.getString("label.show_first")); 3449 showAutoFirst.setState(false); // pending applet parameter 3450 setShowAutoCalculatedAbove(showAutoFirst.getState()); 3451 showAutoLast = new CheckboxMenuItem( 3452 MessageManager.getString("label.show_last")); 3453 showAutoLast.setState(!showAutoFirst.getState()); 3454 showAlignmentAnnotations.addItemListener(this); 3455 showSequenceAnnotations.addItemListener(this); 3456 sortAnnBySequence.addItemListener(this); 3457 sortAnnByLabel.addItemListener(this); 3458 showAutoFirst.addItemListener(this); 3459 showAutoLast.addItemListener(this); 3460 3461 /* 3462 * Configure Format menu items and actions 3463 */ 3464 font.setLabel(MessageManager.getString("action.font")); 3465 font.addActionListener(this); 3466 scaleAbove.setLabel(MessageManager.getString("action.scale_above")); 3467 scaleAbove.setState(true); 3468 scaleAbove.setEnabled(false); 3469 scaleAbove.addItemListener(this); 3470 scaleLeft.setEnabled(false); 3471 scaleLeft.setState(true); 3472 scaleLeft.setLabel(MessageManager.getString("action.scale_left")); 3473 scaleLeft.addItemListener(this); 3474 scaleRight.setEnabled(false); 3475 scaleRight.setState(true); 3476 scaleRight.setLabel(MessageManager.getString("action.scale_right")); 3477 scaleRight.addItemListener(this); 3478 viewBoxesMenuItem.setLabel(MessageManager.getString("action.boxes")); 3479 viewBoxesMenuItem.setState(true); 3480 viewBoxesMenuItem.addItemListener(this); 3481 viewTextMenuItem.setLabel(MessageManager.getString("action.text")); 3482 viewTextMenuItem.setState(true); 3483 viewTextMenuItem.addItemListener(this); 3484 colourTextMenuItem 3485 .setLabel(MessageManager.getString("label.colour_text")); 3486 colourTextMenuItem.addItemListener(this); 3487 displayNonconservedMenuItem 3488 .setLabel(MessageManager.getString("label.show_non_conserved")); 3489 displayNonconservedMenuItem.addItemListener(this); 3490 wrapMenuItem.setLabel(MessageManager.getString("action.wrap")); 3491 wrapMenuItem.addItemListener(this); 3492 renderGapsMenuItem 3493 .setLabel(MessageManager.getString("action.show_gaps")); 3494 renderGapsMenuItem.setState(true); 3495 renderGapsMenuItem.addItemListener(this); 3496 centreColumnLabelFlag.setLabel( 3497 MessageManager.getString("label.centre_column_labels")); 3498 centreColumnLabelFlag.addItemListener(this); 3499 seqLimits.setState(true); 3500 seqLimits.setLabel( 3501 MessageManager.getString("label.show_sequence_limits")); 3502 seqLimits.addItemListener(this); 3503 3504 /* 3505 * Configure Colour menu items and actions 3506 */ 3507 applyToAllGroups.setLabel( 3508 MessageManager.getString("label.apply_colour_to_all_groups")); 3509 applyToAllGroups.setState(true); 3510 applyToAllGroups.addItemListener(this); 3511 clustalColour.setLabel( 3512 MessageManager.getString("label.colourScheme_clustal")); 3513 clustalColour.addActionListener(this); 3514 zappoColour 3515 .setLabel(MessageManager.getString("label.colourScheme_zappo")); 3516 zappoColour.addActionListener(this); 3517 taylorColour.setLabel( 3518 MessageManager.getString("label.colourScheme_taylor")); 3519 taylorColour.addActionListener(this); 3520 hydrophobicityColour.setLabel( 3521 MessageManager.getString("label.colourScheme_hydrophobic")); 3522 hydrophobicityColour.addActionListener(this); 3523 helixColour.setLabel(MessageManager 3524 .getString("label.colourScheme_helix_propensity")); 3525 helixColour.addActionListener(this); 3526 strandColour.setLabel(MessageManager 3527 .getString("label.colourScheme_strand_propensity")); 3528 strandColour.addActionListener(this); 3529 turnColour.setLabel( 3530 MessageManager.getString("label.colourScheme_turn_propensity")); 3531 turnColour.addActionListener(this); 3532 buriedColour.setLabel( 3533 MessageManager.getString("label.colourScheme_buried_index")); 3534 buriedColour.addActionListener(this); 3535 purinePyrimidineColour.setLabel(MessageManager 3536 .getString("label.colourScheme_purine/pyrimidine")); 3537 purinePyrimidineColour.addActionListener(this); 3538 // RNAInteractionColour.setLabel(MessageManager 3539 // .getString("label.rna_interaction")); 3540 // RNAInteractionColour.addActionListener(this); 3541 RNAHelixColour.setLabel( 3542 MessageManager.getString("label.colourScheme_rna_helices")); 3543 RNAHelixColour.addActionListener(this); 3544 userDefinedColour 3545 .setLabel(MessageManager.getString("action.user_defined")); 3546 userDefinedColour.addActionListener(this); 3547 PIDColour.setLabel( 3548 MessageManager.getString("label.colourScheme_%_identity")); 3549 PIDColour.addActionListener(this); 3550 BLOSUM62Colour.setLabel( 3551 MessageManager.getString("label.colourScheme_blosum62")); 3552 BLOSUM62Colour.addActionListener(this); 3553 tcoffeeColour.setLabel( 3554 MessageManager.getString("label.colourScheme_t-coffee_scores")); 3555 // it will be enabled only if a score file is provided 3556 tcoffeeColour.setEnabled(false); 3557 tcoffeeColour.addActionListener(this); 3558 conservationMenuItem 3559 .setLabel(MessageManager.getString("action.by_conservation")); 3560 conservationMenuItem.addItemListener(this); 3561 noColourmenuItem.setLabel(MessageManager.getString("label.none")); 3562 noColourmenuItem.addActionListener(this); 3563 abovePIDThreshold.setLabel( 3564 MessageManager.getString("label.above_identity_threshold")); 3565 abovePIDThreshold.addItemListener(this); 3566 nucleotideColour.setLabel( 3567 MessageManager.getString("label.colourScheme_nucleotide")); 3568 nucleotideColour.addActionListener(this); 3569 modifyPID.setLabel( 3570 MessageManager.getString("label.modify_identity_threshold")); 3571 modifyPID.setEnabled(abovePIDThreshold.getState()); 3572 modifyPID.addActionListener(this); 3573 modifyConservation.setLabel(MessageManager 3574 .getString("label.modify_conservation_threshold")); 3575 modifyConservation.setEnabled(conservationMenuItem.getState()); 3576 modifyConservation.addActionListener(this); 3577 annotationColour 3578 .setLabel(MessageManager.getString("action.by_annotation")); 3579 annotationColour.addActionListener(this); 3580 3581 /* 3582 * Configure Calculate menu items and actions 3583 */ 3584 sortPairwiseMenuItem 3585 .setLabel(MessageManager.getString("action.by_pairwise_id")); 3586 sortPairwiseMenuItem.addActionListener(this); 3587 sortIDMenuItem.setLabel(MessageManager.getString("action.by_id")); 3588 sortIDMenuItem.addActionListener(this); 3589 sortLengthMenuItem 3590 .setLabel(MessageManager.getString("action.by_length")); 3591 sortLengthMenuItem.addActionListener(this); 3592 sortGroupMenuItem.setLabel(MessageManager.getString("action.by_group")); 3593 sortGroupMenuItem.addActionListener(this); 3594 pairwiseAlignmentMenuItem.setLabel( 3595 MessageManager.getString("action.pairwise_alignment")); 3596 pairwiseAlignmentMenuItem.addActionListener(this); 3597 PCAMenuItem.setLabel( 3598 MessageManager.getString("label.principal_component_analysis")); 3599 PCAMenuItem.addActionListener(this); 3600 autoCalculate = new CheckboxMenuItem( 3601 MessageManager.getString("label.autocalculate_consensus"), 3602 true); 3603 averageDistanceTreeMenuItem.setLabel( 3604 MessageManager.getString("label.average_distance_identity")); 3605 averageDistanceTreeMenuItem.addActionListener(this); 3606 neighbourTreeMenuItem.setLabel( 3607 MessageManager.getString("label.neighbour_joining_identity")); 3608 neighbourTreeMenuItem.addActionListener(this); 3609 avDistanceTreeBlosumMenuItem.setLabel( 3610 MessageManager.getString("label.average_distance_blosum62")); 3611 avDistanceTreeBlosumMenuItem.addActionListener(this); 3612 njTreeBlosumMenuItem 3613 .setLabel(MessageManager.getString("label.neighbour_blosum62")); 3614 njTreeBlosumMenuItem.addActionListener(this); 3615 sortByTreeMenu 3616 .setLabel(MessageManager.getString("action.by_tree_order")); 3617 Menu sortMenu = new Menu(MessageManager.getString("action.sort")); 3618 Menu calculateTreeMenu = new Menu( 3619 MessageManager.getString("action.calculate_tree")); 3620 autoCalculate.addItemListener(this); 3621 sortByTree.addItemListener(this); 3622 3623 /* 3624 * Configure Help menu items and actions 3625 */ 3626 Menu helpMenu = new Menu(MessageManager.getString("action.help")); 3627 documentation.setLabel(MessageManager.getString("label.documentation")); 3628 documentation.addActionListener(this); 3629 about.setLabel(MessageManager.getString("label.about")); 3630 about.addActionListener(this); 3631 3632 /* 3633 * Add top level menus to frame 3634 */ 3635 alignFrameMenuBar.add(fileMenu); 3636 Menu editMenu = new Menu(MessageManager.getString("action.edit")); 3637 alignFrameMenuBar.add(editMenu); 3638 Menu selectMenu = new Menu(MessageManager.getString("action.select")); 3639 alignFrameMenuBar.add(selectMenu); 3640 Menu viewMenu = new Menu(MessageManager.getString("action.view")); 3641 alignFrameMenuBar.add(viewMenu); 3642 Menu annotationsMenu = new Menu( 3643 MessageManager.getString("action.annotations")); 3644 alignFrameMenuBar.add(annotationsMenu); 3645 Menu formatMenu = new Menu(MessageManager.getString("action.format")); 3646 alignFrameMenuBar.add(formatMenu); 3647 Menu colourMenu = new Menu(MessageManager.getString("action.colour")); 3648 alignFrameMenuBar.add(colourMenu); 3649 Menu calculateMenu = new Menu( 3650 MessageManager.getString("action.calculate")); 3651 alignFrameMenuBar.add(calculateMenu); 3652 alignFrameMenuBar.add(helpMenu); 3653 3654 /* 3655 * File menu 3656 */ 3657 fileMenu.add(inputText); 3658 fileMenu.add(loadTree); 3659 fileMenu.add(loadAnnotations); 3660 fileMenu.addSeparator(); 3661 fileMenu.add(outputTextboxMenu); 3662 fileMenu.add(outputFeatures); 3663 fileMenu.add(outputAnnotations); 3664 if (jalviewServletURL != null) 3665 { 3666 fileMenu.add(loadApplication); 3667 } 3668 fileMenu.addSeparator(); 3669 fileMenu.add(closeMenuItem); 3670 3671 /* 3672 * Edit menu 3673 */ 3674 editMenu.add(undoMenuItem); 3675 editMenu.add(redoMenuItem); 3676 editMenu.add(cut); 3677 editMenu.add(copy); 3678 pasteMenu.add(pasteNew); 3679 pasteMenu.add(pasteThis); 3680 editMenu.add(pasteMenu); 3681 editMenu.add(delete); 3682 editMenu.addSeparator(); 3683 editMenu.add(remove2LeftMenuItem); 3684 editMenu.add(remove2RightMenuItem); 3685 editMenu.add(removeGappedColumnMenuItem); 3686 editMenu.add(removeAllGapsMenuItem); 3687 editMenu.add(removeRedundancyMenuItem); 3688 3689 /* 3690 * Select menu 3691 */ 3692 selectMenu.add(findMenuItem); 3693 selectMenu.addSeparator(); 3694 selectMenu.add(selectAllSequenceMenuItem); 3695 selectMenu.add(deselectAllSequenceMenuItem); 3696 selectMenu.add(invertSequenceMenuItem); 3697 selectMenu.add(invertColSel); 3698 selectMenu.add(createGroup); 3699 selectMenu.add(unGroup); 3700 selectMenu.add(grpsFromSelection); 3701 selectMenu.add(deleteGroups); 3702 selectMenu.add(annotationColumnSelection); 3703 3704 /* 3705 * View menu 3706 */ 3707 viewMenu.add(newView); 3708 viewMenu.addSeparator(); 3709 showMenu.add(showColumns); 3710 showMenu.add(showSeqs); 3711 showMenu.add(showAllHidden); 3712 viewMenu.add(showMenu); 3713 hideMenu.add(hideColumns); 3714 hideMenu.add(hideSequences); 3715 hideMenu.add(hideAllSelection); 3716 hideMenu.add(hideAllButSelection); 3717 viewMenu.add(hideMenu); 3718 viewMenu.addSeparator(); 3719 viewMenu.add(followMouseOverFlag); 3720 viewMenu.addSeparator(); 3721 viewMenu.add(sequenceFeatures); 3722 viewMenu.add(featureSettings); 3723 viewMenu.addSeparator(); 3724 viewMenu.add(alProperties); 3725 viewMenu.addSeparator(); 3726 viewMenu.add(overviewMenuItem); 3727 3728 /* 3729 * Annotations menu 3730 */ 3731 annotationsMenu.add(annotationPanelMenuItem); 3732 annotationsMenu.addSeparator(); 3733 annotationsMenu.add(showAlignmentAnnotations); 3734 annotationsMenu.add(showSequenceAnnotations); 3735 annotationsMenu.add(sortAnnBySequence); 3736 annotationsMenu.add(sortAnnByLabel); 3737 annotationsMenu.addSeparator(); 3738 autoAnnMenu.add(showAutoFirst); 3739 autoAnnMenu.add(showAutoLast); 3740 autoAnnMenu.addSeparator(); 3741 autoAnnMenu.add(applyAutoAnnotationSettings); 3742 autoAnnMenu.add(showConsensusHistogram); 3743 autoAnnMenu.add(showSequenceLogo); 3744 autoAnnMenu.add(normSequenceLogo); 3745 autoAnnMenu.addSeparator(); 3746 autoAnnMenu.add(showGroupConservation); 3747 autoAnnMenu.add(showGroupConsensus); 3748 annotationsMenu.add(autoAnnMenu); 3749 3750 /* 3751 * Format menu 3752 */ 3753 formatMenu.add(font); 3754 formatMenu.add(seqLimits); 3755 formatMenu.add(wrapMenuItem); 3756 formatMenu.add(scaleAbove); 3757 formatMenu.add(scaleLeft); 3758 formatMenu.add(scaleRight); 3759 formatMenu.add(viewBoxesMenuItem); 3760 formatMenu.add(viewTextMenuItem); 3761 formatMenu.add(colourTextMenuItem); 3762 formatMenu.add(displayNonconservedMenuItem); 3763 formatMenu.add(renderGapsMenuItem); 3764 formatMenu.add(centreColumnLabelFlag); 3765 3766 /* 3767 * Colour menu 3768 */ 3769 colourMenu.add(applyToAllGroups); 3770 colourMenu.addSeparator(); 3771 colourMenu.add(noColourmenuItem); 3772 colourMenu.add(clustalColour); 3773 colourMenu.add(BLOSUM62Colour); 3774 colourMenu.add(PIDColour); 3775 colourMenu.add(zappoColour); 3776 colourMenu.add(taylorColour); 3777 colourMenu.add(hydrophobicityColour); 3778 colourMenu.add(helixColour); 3779 colourMenu.add(strandColour); 3780 colourMenu.add(turnColour); 3781 colourMenu.add(buriedColour); 3782 colourMenu.add(nucleotideColour); 3783 colourMenu.add(purinePyrimidineColour); 3784 // colourMenu.add(RNAInteractionColour); 3785 colourMenu.add(tcoffeeColour); 3786 colourMenu.add(userDefinedColour); 3787 colourMenu.addSeparator(); 3788 colourMenu.add(conservationMenuItem); 3789 colourMenu.add(modifyConservation); 3790 colourMenu.add(abovePIDThreshold); 3791 colourMenu.add(modifyPID); 3792 colourMenu.add(annotationColour); 3793 colourMenu.add(RNAHelixColour); 3794 3795 /* 3796 * Calculate menu 3797 */ 3798 sortMenu.add(sortIDMenuItem); 3799 sortMenu.add(sortLengthMenuItem); 3800 sortMenu.add(sortByTreeMenu); 3801 sortMenu.add(sortGroupMenuItem); 3802 sortMenu.add(sortPairwiseMenuItem); 3803 calculateMenu.add(sortMenu); 3804 calculateTreeMenu.add(averageDistanceTreeMenuItem); 3805 calculateTreeMenu.add(neighbourTreeMenuItem); 3806 calculateTreeMenu.add(avDistanceTreeBlosumMenuItem); 3807 calculateTreeMenu.add(njTreeBlosumMenuItem); 3808 calculateMenu.add(calculateTreeMenu); 3809 calculateMenu.addSeparator(); 3810 calculateMenu.add(pairwiseAlignmentMenuItem); 3811 calculateMenu.add(PCAMenuItem); 3812 calculateMenu.add(autoCalculate); 3813 calculateMenu.add(sortByTree); 3814 3815 /* 3816 * Help menu 3817 */ 3818 helpMenu.add(documentation); 3819 helpMenu.add(about); 3820 3821 /* 3822 * Status bar 3823 */ 3824 statusBar.setBackground(Color.white); 3825 statusBar.setFont(new java.awt.Font("Verdana", 0, 11)); 3826 statusBar.setText(MessageManager.getString("label.status_bar")); 3827 this.add(statusBar, BorderLayout.SOUTH); 3828 } 3829 3830 @Override setStatus(String string)3831 public void setStatus(String string) 3832 { 3833 statusBar.setText(string); 3834 }; 3835 3836 MenuItem featureSettings = new MenuItem(); 3837 3838 CheckboxMenuItem sequenceFeatures = new CheckboxMenuItem(); 3839 3840 MenuItem annotationColour = new MenuItem(); 3841 3842 MenuItem annotationColumnSelection = new MenuItem(); 3843 3844 MenuItem invertColSel = new MenuItem(); 3845 3846 MenuItem showColumns = new MenuItem(); 3847 3848 MenuItem showSeqs = new MenuItem(); 3849 3850 MenuItem hideColumns = new MenuItem(); 3851 3852 MenuItem hideSequences = new MenuItem(); 3853 3854 MenuItem hideAllButSelection = new MenuItem(); 3855 3856 MenuItem hideAllSelection = new MenuItem(); 3857 3858 MenuItem showAllHidden = new MenuItem(); 3859 3860 MenuItem newView = new MenuItem(); 3861 3862 private CheckboxMenuItem showAlignmentAnnotations; 3863 3864 private CheckboxMenuItem showSequenceAnnotations; 3865 3866 private CheckboxMenuItem sortAnnBySequence; 3867 3868 private CheckboxMenuItem sortAnnByLabel; 3869 3870 private CheckboxMenuItem showAutoFirst; 3871 3872 private CheckboxMenuItem showAutoLast; 3873 3874 private SplitFrame splitFrame; 3875 3876 /** 3877 * Attach the alignFrame panels after embedding menus, if necessary. This used 3878 * to be called setEmbedded, but is now creates the dropdown menus in a 3879 * platform independent manner to avoid OSX/Mac menu appendage daftness. 3880 * 3881 * @param reallyEmbedded 3882 * true to attach the view to the applet area on the page rather than 3883 * in a new window 3884 */ createAlignFrameWindow(boolean reallyEmbedded)3885 public void createAlignFrameWindow(boolean reallyEmbedded) 3886 { 3887 if (reallyEmbedded) 3888 { 3889 embedAlignFrameInApplet(viewport.applet); 3890 } 3891 else 3892 { 3893 // ////// 3894 // test and embed menu bar if necessary. 3895 // 3896 if (embedMenuIfNeeded(alignPanel)) 3897 { 3898 /* 3899 * adjust for status bar height too. ? pointless as overridden by layout 3900 * manager 3901 */ 3902 alignPanel.setSize(getSize().width, 3903 getSize().height - statusBar.getHeight()); 3904 } 3905 add(statusBar, BorderLayout.SOUTH); 3906 add(alignPanel, BorderLayout.CENTER); 3907 // and register with the applet so it can pass external API calls to us 3908 jalview.bin.JalviewLite.addFrame(this, this.getTitle(), frameWidth, 3909 frameHeight); 3910 } 3911 } 3912 3913 /** 3914 * Add the components of this AlignFrame to the applet container. 3915 * 3916 * @param theApplet 3917 */ embedAlignFrameInApplet(final JalviewLite theApplet)3918 public void embedAlignFrameInApplet(final JalviewLite theApplet) 3919 { 3920 // //// 3921 // Explicitly build the embedded menu panel for the on-page applet 3922 // 3923 // view cannot be closed if its actually on the page 3924 fileMenu.remove(closeMenuItem); 3925 fileMenu.remove(3); // Remove Separator 3926 // construct embedded menu, using default font 3927 embeddedMenu = makeEmbeddedPopupMenu(alignFrameMenuBar, false, false); 3928 // and actually add the components to the applet area 3929 theApplet.setLayout(new BorderLayout()); 3930 theApplet.add(embeddedMenu, BorderLayout.NORTH); 3931 theApplet.add(statusBar, BorderLayout.SOUTH); 3932 // TODO should size be left to the layout manager? 3933 alignPanel.setSize(theApplet.getSize().width, theApplet.getSize().height 3934 - embeddedMenu.getHeight() - statusBar.getHeight()); 3935 theApplet.add(alignPanel, BorderLayout.CENTER); 3936 final AlignFrame me = this; 3937 theApplet.addFocusListener(new FocusListener() 3938 { 3939 3940 @Override 3941 public void focusLost(FocusEvent e) 3942 { 3943 if (theApplet.currentAlignFrame == me) 3944 { 3945 theApplet.currentAlignFrame = null; 3946 } 3947 } 3948 3949 @Override 3950 public void focusGained(FocusEvent e) 3951 { 3952 theApplet.currentAlignFrame = me; 3953 } 3954 }); 3955 theApplet.validate(); 3956 } 3957 3958 /** 3959 * create a new binding between structures in an existing jmol viewer instance 3960 * and an alignpanel with sequences that have existing PDBFile entries. Note, 3961 * this does not open a new Jmol window, or modify the display of the 3962 * structures in the original jmol window. Note This method doesn't work 3963 * without an additional javascript library to exchange messages between the 3964 * distinct applets. See http://issues.jalview.org/browse/JAL-621 3965 * 3966 * @param viewer 3967 * JmolViewer instance 3968 * @param sequenceIds 3969 * - sequence Ids to search for associations 3970 */ addStructureViewInstance( Object jmolviewer, String[] sequenceIds)3971 public SequenceStructureBinding addStructureViewInstance( 3972 Object jmolviewer, String[] sequenceIds) 3973 { 3974 Viewer viewer = null; 3975 try 3976 { 3977 viewer = (Viewer) jmolviewer; 3978 } catch (ClassCastException ex) 3979 { 3980 System.err.println( 3981 "Unsupported viewer object :" + jmolviewer.getClass()); 3982 } 3983 if (viewer == null) 3984 { 3985 System.err.println("Can't use this object as a structure viewer:" 3986 + jmolviewer.getClass()); 3987 return null; 3988 } 3989 SequenceI[] seqs = null; 3990 if (sequenceIds == null || sequenceIds.length == 0) 3991 { 3992 seqs = viewport.getAlignment().getSequencesArray(); 3993 } 3994 else 3995 { 3996 Vector sqi = new Vector(); 3997 AlignmentI al = viewport.getAlignment(); 3998 for (int sid = 0; sid < sequenceIds.length; sid++) 3999 { 4000 SequenceI sq = al.findName(sequenceIds[sid]); 4001 if (sq != null) 4002 { 4003 sqi.addElement(sq); 4004 } 4005 } 4006 if (sqi.size() > 0) 4007 { 4008 seqs = new SequenceI[sqi.size()]; 4009 for (int sid = 0, sSize = sqi.size(); sid < sSize; sid++) 4010 { 4011 seqs[sid] = (SequenceI) sqi.elementAt(sid); 4012 } 4013 } 4014 else 4015 { 4016 return null; 4017 } 4018 } 4019 AAStructureBindingModel jmv = null; 4020 // TODO: search for a jmv that involves viewer 4021 if (jmv == null) 4022 { // create a new viewer/jalview binding. 4023 jmv = new ExtJmol(viewer, alignPanel, new SequenceI[][] { seqs }); 4024 } 4025 return jmv; 4026 4027 } 4028 4029 /** 4030 * bind a pdb file to a sequence in the current view 4031 * 4032 * @param sequenceId 4033 * - sequenceId within the dataset. 4034 * @param pdbEntryString 4035 * - the short name for the PDB file 4036 * @param pdbFile 4037 * - pdb file - either a URL or a valid PDB file. 4038 * @return true if binding was as success TODO: consider making an exception 4039 * structure for indicating when PDB parsing or sequenceId location 4040 * fails. 4041 */ addPdbFile(String sequenceId, String pdbEntryString, String pdbFile)4042 public boolean addPdbFile(String sequenceId, String pdbEntryString, 4043 String pdbFile) 4044 { 4045 SequenceI toaddpdb = viewport.getAlignment().findName(sequenceId); 4046 boolean needtoadd = false; 4047 if (toaddpdb != null) 4048 { 4049 Vector pdbe = toaddpdb.getAllPDBEntries(); 4050 PDBEntry pdbentry = null; 4051 if (pdbe != null && pdbe.size() > 0) 4052 { 4053 for (int pe = 0, peSize = pdbe.size(); pe < peSize; pe++) 4054 { 4055 pdbentry = (PDBEntry) pdbe.elementAt(pe); 4056 if (!pdbentry.getId().equals(pdbEntryString) 4057 && !pdbentry.getFile().equals(pdbFile)) 4058 { 4059 pdbentry = null; 4060 } 4061 else 4062 { 4063 continue; 4064 } 4065 } 4066 } 4067 if (pdbentry == null) 4068 { 4069 pdbentry = new PDBEntry(); 4070 pdbentry.setId(pdbEntryString); 4071 pdbentry.setFile(pdbFile); 4072 needtoadd = true; // add this new entry to sequence. 4073 } 4074 // resolve data source 4075 // TODO: this code should be a refactored to an io package 4076 DataSourceType protocol = AppletFormatAdapter.resolveProtocol(pdbFile, 4077 FileFormat.PDB); 4078 if (protocol == null) 4079 { 4080 return false; 4081 } 4082 if (needtoadd) 4083 { 4084 pdbentry.setProperty("protocol", protocol); 4085 toaddpdb.addPDBId(pdbentry); 4086 alignPanel.getStructureSelectionManager() 4087 .registerPDBEntry(pdbentry); 4088 } 4089 } 4090 return true; 4091 } 4092 cleanSeqChainArrays(SequenceI[] seqs, String[] chains)4093 private Object[] cleanSeqChainArrays(SequenceI[] seqs, String[] chains) 4094 { 4095 if (seqs != null) 4096 { 4097 Vector sequences = new Vector(); 4098 for (int i = 0; i < seqs.length; i++) 4099 { 4100 if (seqs[i] != null) 4101 { 4102 sequences 4103 .addElement(new Object[] 4104 { seqs[i], (chains != null) ? chains[i] : null }); 4105 } 4106 } 4107 seqs = new SequenceI[sequences.size()]; 4108 chains = new String[sequences.size()]; 4109 for (int i = 0, isize = sequences.size(); i < isize; i++) 4110 { 4111 Object[] oj = (Object[]) sequences.elementAt(i); 4112 4113 seqs[i] = (SequenceI) oj[0]; 4114 chains[i] = (String) oj[1]; 4115 } 4116 } 4117 return new Object[] { seqs, chains }; 4118 4119 } 4120 newStructureView(JalviewLite applet, PDBEntry pdb, SequenceI[] seqs, String[] chains, DataSourceType protocol)4121 public void newStructureView(JalviewLite applet, PDBEntry pdb, 4122 SequenceI[] seqs, String[] chains, DataSourceType protocol) 4123 { 4124 // Scrub any null sequences from the array 4125 Object[] sqch = cleanSeqChainArrays(seqs, chains); 4126 seqs = (SequenceI[]) sqch[0]; 4127 chains = (String[]) sqch[1]; 4128 if (seqs == null || seqs.length == 0) 4129 { 4130 System.err.println( 4131 "JalviewLite.AlignFrame:newStructureView: No sequence to bind structure to."); 4132 } 4133 if (protocol == null) 4134 { 4135 String sourceType = (String) pdb.getProperty("protocol"); 4136 try 4137 { 4138 protocol = DataSourceType.valueOf(sourceType); 4139 } catch (IllegalArgumentException e) 4140 { 4141 // ignore 4142 } 4143 if (protocol == null) 4144 { 4145 System.err.println("Couldn't work out protocol to open structure: " 4146 + pdb.getId()); 4147 return; 4148 } 4149 } 4150 if (applet.useXtrnalSviewer) 4151 { 4152 // register the association(s) and quit, don't create any windows. 4153 if (StructureSelectionManager.getStructureSelectionManager(applet) 4154 .setMapping(seqs, chains, pdb.getFile(), protocol, null) == null) 4155 { 4156 System.err.println("Failed to map " + pdb.getFile() + " (" 4157 + protocol + ") to any sequences"); 4158 } 4159 return; 4160 } 4161 if (applet.isAlignPdbStructures() && applet.jmolAvailable) 4162 { 4163 // can only do alignments with Jmol 4164 // find the last jmol window assigned to this alignment 4165 AppletJmol ajm = null, tajm; 4166 Vector jmols = applet.getAppletWindow(AppletJmol.class); 4167 for (int i = 0, iSize = jmols.size(); i < iSize; i++) 4168 { 4169 tajm = (AppletJmol) jmols.elementAt(i); 4170 if (tajm.ap.alignFrame == this) 4171 { 4172 ajm = tajm; 4173 break; 4174 } 4175 } 4176 if (ajm != null) 4177 { 4178 System.err.println( 4179 "Incremental adding and aligning structure to existing Jmol view not yet implemented."); 4180 // try and add the pdb structure 4181 // ajm.addS 4182 ajm = null; 4183 } 4184 } 4185 // otherwise, create a new window 4186 if (applet.jmolAvailable) 4187 { 4188 new AppletJmol(pdb, seqs, chains, alignPanel, protocol); 4189 applet.lastFrameX += 40; 4190 applet.lastFrameY += 40; 4191 } 4192 else 4193 { 4194 new MCview.AppletPDBViewer(pdb, seqs, chains, alignPanel, protocol); 4195 } 4196 4197 } 4198 alignedStructureView(JalviewLite applet, PDBEntry[] pdb, SequenceI[][] seqs, String[][] chains, String[] protocols)4199 public void alignedStructureView(JalviewLite applet, PDBEntry[] pdb, 4200 SequenceI[][] seqs, String[][] chains, String[] protocols) 4201 { 4202 // TODO Auto-generated method stub 4203 System.err.println("Aligned Structure View: Not yet implemented."); 4204 } 4205 4206 /** 4207 * modify the current selection, providing the user has not made a selection 4208 * already. 4209 * 4210 * @param sel 4211 * - sequences from this alignment 4212 * @param csel 4213 * - columns to be selected on the alignment 4214 */ select(SequenceGroup sel, ColumnSelection csel, HiddenColumns hidden)4215 public void select(SequenceGroup sel, ColumnSelection csel, 4216 HiddenColumns hidden) 4217 { 4218 alignPanel.seqPanel.selection(sel, csel, hidden, null); 4219 } 4220 scrollTo(int row, int column)4221 public void scrollTo(int row, int column) 4222 { 4223 alignPanel.seqPanel.scrollTo(row, column); 4224 } 4225 scrollToRow(int row)4226 public void scrollToRow(int row) 4227 { 4228 alignPanel.seqPanel.scrollToRow(row); 4229 } 4230 scrollToColumn(int column)4231 public void scrollToColumn(int column) 4232 { 4233 alignPanel.seqPanel.scrollToColumn(column); 4234 } 4235 4236 /** 4237 * @return the alignments unique ID. 4238 */ getSequenceSetId()4239 public String getSequenceSetId() 4240 { 4241 return viewport.getSequenceSetId(); 4242 } 4243 4244 /** 4245 * Load the (T-Coffee) score file from the specified url 4246 * 4247 * @param source 4248 * File/URL/T-COFFEE score file contents 4249 * @throws IOException 4250 * @return true if alignment was annotated with data from source 4251 */ loadScoreFile(String source)4252 public boolean loadScoreFile(String source) throws IOException 4253 { 4254 4255 TCoffeeScoreFile file = new TCoffeeScoreFile(source, 4256 AppletFormatAdapter.checkProtocol(source)); 4257 if (!file.isValid()) 4258 { 4259 // TODO: raise dialog for gui 4260 System.err.println("Problems parsing T-Coffee scores: " 4261 + file.getWarningMessage()); 4262 System.err.println("Origin was:\n" + source); 4263 return false; 4264 } 4265 4266 /* 4267 * check that the score matrix matches the alignment dimensions 4268 */ 4269 AlignmentI aln; 4270 if ((aln = viewport.getAlignment()) != null 4271 && (aln.getHeight() != file.getHeight() 4272 || aln.getWidth() != file.getWidth())) 4273 { 4274 // TODO: raise a dialog box here rather than bomb out. 4275 System.err.println( 4276 "The scores matrix does not match the alignment dimensions"); 4277 4278 } 4279 4280 // TODO add parameter to indicate if matching should be done 4281 if (file.annotateAlignment(alignPanel.getAlignment(), false)) 4282 { 4283 alignPanel.fontChanged(); 4284 tcoffeeColour.setEnabled(true); 4285 // switch to this color 4286 changeColour(new TCoffeeColourScheme(alignPanel.getAlignment())); 4287 return true; 4288 } 4289 else 4290 { 4291 System.err.println("Problems resolving T-Coffee scores:"); 4292 if (file.getWarningMessage() != null) 4293 { 4294 System.err.println(file.getWarningMessage()); 4295 } 4296 } 4297 return false; 4298 } 4299 getSplitFrame()4300 public SplitFrame getSplitFrame() 4301 { 4302 return this.splitFrame; 4303 } 4304 setSplitFrame(SplitFrame sf)4305 public void setSplitFrame(SplitFrame sf) 4306 { 4307 this.splitFrame = sf; 4308 } 4309 4310 // may not need this 4311 @Override setShowSeqFeatures(boolean b)4312 public void setShowSeqFeatures(boolean b) 4313 { 4314 // showSeqFeatures.setSelected(b); 4315 viewport.setShowSequenceFeatures(b); 4316 4317 } 4318 4319 @Override setMenusForViewport()4320 public void setMenusForViewport() 4321 { 4322 // setMenusFromViewport(viewport); 4323 4324 } 4325 4326 @Override refreshFeatureUI(boolean enableIfNecessary)4327 public void refreshFeatureUI(boolean enableIfNecessary) 4328 { 4329 if (enableIfNecessary) 4330 { 4331 sequenceFeatures.setState(true); 4332 alignPanel.av.setShowSequenceFeatures(true); 4333 } 4334 } 4335 4336 @Override getFeatureSettingsUI()4337 public FeatureSettingsControllerI getFeatureSettingsUI() 4338 { 4339 return alignPanel.av.featureSettings; 4340 } 4341 4342 @Override showFeatureSettingsUI()4343 public FeatureSettingsControllerI showFeatureSettingsUI() 4344 { 4345 return new FeatureSettings(alignPanel); 4346 } 4347 4348 private Rectangle fs_bounds = null; 4349 4350 @Override setFeatureSettingsGeometry(Rectangle bounds)4351 public void setFeatureSettingsGeometry(Rectangle bounds) 4352 { 4353 fs_bounds = bounds; 4354 } 4355 4356 @Override getFeatureSettingsGeometry()4357 public Rectangle getFeatureSettingsGeometry() 4358 { 4359 return fs_bounds; 4360 } 4361 4362 } 4363