X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fviewmodel%2FAlignmentViewport.java;h=6cec30a2bd7db21e3e06b4c967b466fc7b7bb43a;hb=ad15cff29620f960119f80176f1fd443da9f6763;hp=fc96f62df9e4865a9f98ad184901cd6f49cf7007;hpb=f2b6ee8c1feb4f6a7e229ee94741ef93f0bd453d;p=jalview.git diff --git a/src/jalview/viewmodel/AlignmentViewport.java b/src/jalview/viewmodel/AlignmentViewport.java index fc96f62..6cec30a 100644 --- a/src/jalview/viewmodel/AlignmentViewport.java +++ b/src/jalview/viewmodel/AlignmentViewport.java @@ -1,19 +1,22 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8) - * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * * Jalview is free software: you can redistribute it and/or * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. - * + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * * Jalview is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License along with Jalview. If not, see . + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.viewmodel; @@ -21,23 +24,30 @@ import jalview.analysis.Conservation; import jalview.api.AlignCalcManagerI; import jalview.api.AlignViewportI; import jalview.api.AlignmentViewPanel; +import jalview.api.FeaturesDisplayedI; import jalview.datamodel.AlignmentAnnotation; import jalview.datamodel.AlignmentI; import jalview.datamodel.AlignmentView; import jalview.datamodel.Annotation; import jalview.datamodel.ColumnSelection; import jalview.datamodel.Sequence; +import jalview.datamodel.SequenceCollectionI; import jalview.datamodel.SequenceGroup; import jalview.datamodel.SequenceI; -import jalview.schemes.ClustalxColourScheme; +import jalview.schemes.Blosum62ColourScheme; import jalview.schemes.ColourSchemeI; +import jalview.schemes.PIDColourScheme; import jalview.schemes.ResidueProperties; import jalview.workers.AlignCalcManager; import jalview.workers.ConsensusThread; -import jalview.workers.ConservationThread; import jalview.workers.StrucConsensusThread; +import java.awt.Color; +import java.util.ArrayList; +import java.util.BitSet; import java.util.Hashtable; +import java.util.List; +import java.util.Map; import java.util.Vector; /** @@ -62,7 +72,7 @@ public abstract class AlignmentViewport implements AlignViewportI */ protected boolean isDataset = false; - private Hashtable hiddenRepSequences; + private Map hiddenRepSequences; protected ColumnSelection colSel = new ColumnSelection(); @@ -74,12 +84,202 @@ public abstract class AlignmentViewport implements AlignViewportI protected ColourSchemeI globalColourScheme = null; + /** + * gui state - changes to colour scheme propagated to all groups + */ + private boolean colourAppliesToAllGroups; + + /** + * @param value + * indicating if subsequent colourscheme changes will be propagated + * to all groups + */ + public void setColourAppliesToAllGroups(boolean b) + { + colourAppliesToAllGroups = b; + } + + /** + * + * + * @return flag indicating if colourchanges propagated to all groups + */ + public boolean getColourAppliesToAllGroups() + { + return colourAppliesToAllGroups; + } + + boolean abovePIDThreshold = false; + + /** + * GUI state + * + * @return true if percent identity threshold is applied to shading + */ + public boolean getAbovePIDThreshold() + { + return abovePIDThreshold; + } + + /** + * GUI state + * + * + * @param b + * indicate if percent identity threshold is applied to shading + */ + public void setAbovePIDThreshold(boolean b) + { + abovePIDThreshold = b; + } + + int threshold; + + /** + * DOCUMENT ME! + * + * @param thresh + * DOCUMENT ME! + */ + public void setThreshold(int thresh) + { + threshold = thresh; + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ + public int getThreshold() + { + return threshold; + } + + int increment; + + /** + * + * @param inc + * set the scalar for bleaching colourschemes according to degree of + * conservation + */ + public void setIncrement(int inc) + { + increment = inc; + } + + /** + * GUI State + * + * @return get scalar for bleaching colourschemes by conservation + */ + public int getIncrement() + { + return increment; + } + + boolean conservationColourSelected = false; + + /** + * GUI state + * + * @return true if conservation based shading is enabled + */ + public boolean getConservationSelected() + { + return conservationColourSelected; + } + + /** + * GUI state + * + * @param b + * enable conservation based shading + */ + public void setConservationSelected(boolean b) + { + conservationColourSelected = b; + } + @Override public void setGlobalColourScheme(ColourSchemeI cs) { + // TODO: logic refactored from AlignFrame changeColour - + // autorecalc stuff should be changed to rely on the worker system + // check to see if we should implement a changeColour(cs) method rather than + // put th logic in here + // - means that caller decides if they want to just modify state and defer + // calculation till later or to do all calculations in thread. + // via changecolour globalColourScheme = cs; + boolean recalc = false; + if (cs != null) + { + cs.setConservationApplied(recalc = getConservationSelected()); + if (getAbovePIDThreshold() || cs instanceof PIDColourScheme + || cs instanceof Blosum62ColourScheme) + { + recalc = true; + cs.setThreshold(threshold, ignoreGapsInConsensusCalculation); + } + else + { + cs.setThreshold(0, ignoreGapsInConsensusCalculation); + } + if (recalc) + { + cs.setConsensus(hconsensus); + cs.setConservation(hconservation); + } + cs.alignmentChanged(alignment, hiddenRepSequences); + } + if (getColourAppliesToAllGroups()) + { + for (SequenceGroup sg : getAlignment().getGroups()) + { + if (cs == null) + { + sg.cs = null; + continue; + } + sg.cs = cs.applyTo(sg, getHiddenRepSequences()); + sg.setConsPercGaps(ConsPercGaps); + if (getAbovePIDThreshold() || cs instanceof PIDColourScheme + || cs instanceof Blosum62ColourScheme) + { + sg.cs.setThreshold(threshold, getIgnoreGapsConsensus()); + recalc = true; + } + else + { + sg.cs.setThreshold(0, getIgnoreGapsConsensus()); + } + + if (getConservationSelected()) + { + sg.cs.setConservationApplied(true); + recalc = true; + } + else + { + sg.cs.setConservation(null); + // sg.cs.setThreshold(0, getIgnoreGapsConsensus()); + } + if (recalc) + { + sg.recalcConservation(); + } + else + { + sg.cs.alignmentChanged(sg, hiddenRepSequences); + } + } + } + } + @Override public ColourSchemeI getGlobalColourScheme() { return globalColourScheme; @@ -108,16 +308,26 @@ public abstract class AlignmentViewport implements AlignViewportI */ protected Hashtable[] hStrucConsensus = null; + protected Conservation hconservation = null; + + @Override + public void setConservation(Conservation cons) + { + hconservation = cons; + } + /** * percentage gaps allowed in a column before all amino acid properties should * be considered unconserved */ int ConsPercGaps = 25; // JBPNote : This should be a scalable property! + @Override public int getConsPercGaps() { return ConsPercGaps; } + @Override public void setSequenceConsensusHash(Hashtable[] hconsensus) { @@ -181,8 +391,8 @@ public abstract class AlignmentViewport implements AlignViewportI { return; } - if (!calculator - .startRegisteredWorkersOfClass(jalview.workers.ConservationThread.class)) + if (calculator + .getRegisteredWorkersOfClass(jalview.workers.ConservationThread.class) == null) { calculator.registerWorker(new jalview.workers.ConservationThread( this, ap)); @@ -199,7 +409,7 @@ public abstract class AlignmentViewport implements AlignViewportI { return; } - if (!calculator.startRegisteredWorkersOfClass(ConsensusThread.class)) + if (calculator.getRegisteredWorkersOfClass(ConsensusThread.class) == null) { calculator.registerWorker(new ConsensusThread(this, ap)); } @@ -211,7 +421,8 @@ public abstract class AlignmentViewport implements AlignViewportI if (autoCalculateStrucConsensus && strucConsensus == null && alignment.isNucleotide() && alignment.hasRNAStructure()) { - + // secondary structure has been added - so init the consensus line + initRNAStructure(); } // see note in mantis : issue number 8585 @@ -219,8 +430,7 @@ public abstract class AlignmentViewport implements AlignViewportI { return; } - if (!calculator - .startRegisteredWorkersOfClass(StrucConsensusThread.class)) + if (calculator.getRegisteredWorkersOfClass(StrucConsensusThread.class) == null) { calculator.registerWorker(new StrucConsensusThread(this, ap)); } @@ -231,11 +441,14 @@ public abstract class AlignmentViewport implements AlignViewportI return calculator.isWorking(); } + @Override public boolean isCalculationInProgress( AlignmentAnnotation alignmentAnnotation) { if (!alignmentAnnotation.autoCalculated) + { return false; + } if (calculator.workingInvolvedWith(alignmentAnnotation)) { // System.err.println("grey out ("+alignmentAnnotation.label+")"); @@ -272,10 +485,12 @@ public abstract class AlignmentViewport implements AlignViewportI * should consensus profile be rendered by default */ protected boolean showSequenceLogo = false; + /** * should consensus profile be rendered normalised to row height */ protected boolean normaliseSequenceLogo = false; + /** * should consensus histograms be rendered by default */ @@ -284,6 +499,7 @@ public abstract class AlignmentViewport implements AlignViewportI /** * @return the showConsensusProfile */ + @Override public boolean isShowSequenceLogo() { return showSequenceLogo; @@ -354,6 +570,7 @@ public abstract class AlignmentViewport implements AlignViewportI * @return flag to indicate if the consensus histogram should be rendered by * default */ + @Override public boolean isShowConsensusHistogram() { return this.showConsensusHistogram; @@ -364,7 +581,6 @@ public abstract class AlignmentViewport implements AlignViewportI */ protected boolean showUnconserved = false; - /** * when set, updateAlignment will always ensure sequences are of equal length */ @@ -399,6 +615,7 @@ public abstract class AlignmentViewport implements AlignViewportI * * @return null or the currently selected sequence region */ + @Override public SequenceGroup getSelectionGroup() { return selectionGroup; @@ -411,6 +628,7 @@ public abstract class AlignmentViewport implements AlignViewportI * - group holding references to sequences in this alignment view * */ + @Override public void setSelectionGroup(SequenceGroup sg) { selectionGroup = sg; @@ -419,38 +637,57 @@ public abstract class AlignmentViewport implements AlignViewportI public void setHiddenColumns(ColumnSelection colsel) { this.colSel = colsel; - if (colSel.getHiddenColumns() != null) - { - hasHiddenColumns = true; - } } + @Override public ColumnSelection getColumnSelection() { return colSel; } + @Override public void setColumnSelection(ColumnSelection colSel) { this.colSel = colSel; + if (colSel != null) + { + updateHiddenColumns(); + } } - public Hashtable getHiddenRepSequences() + + /** + * + * @return + */ + @Override + public Map getHiddenRepSequences() { return hiddenRepSequences; } - public void setHiddenRepSequences(Hashtable hiddenRepSequences) + + @Override + public void setHiddenRepSequences( + Map hiddenRepSequences) { this.hiddenRepSequences = hiddenRepSequences; } - protected boolean hasHiddenColumns = false; + + @Override + public boolean hasHiddenColumns() + { + return colSel != null && colSel.hasHiddenColumns(); + } public void updateHiddenColumns() { - hasHiddenColumns = colSel.getHiddenColumns() != null; + // this method doesn't really do anything now. But - it could, since a + // column Selection could be in the process of modification + // hasHiddenColumns = colSel.hasHiddenColumns(); } protected boolean hasHiddenRows = false; + @Override public boolean hasHiddenRows() { return hasHiddenRows; @@ -468,6 +705,7 @@ public abstract class AlignmentViewport implements AlignViewportI sequenceSetID = new String(newid); } + @Override public String getSequenceSetId() { if (sequenceSetID == null) @@ -557,6 +795,7 @@ public abstract class AlignmentViewport implements AlignViewportI return false; } + @Override public boolean getIgnoreGapsConsensus() { return ignoreGapsInConsensusCalculation; @@ -565,7 +804,7 @@ public abstract class AlignmentViewport implements AlignViewportI // / property change stuff // JBPNote Prolly only need this in the applet version. - private java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport( + private final java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport( this); protected boolean showConservation = true; @@ -574,6 +813,7 @@ public abstract class AlignmentViewport implements AlignViewportI protected boolean showConsensus = true; + Hashtable sequenceColours; /** * Property change listener for changes in alignment @@ -616,7 +856,6 @@ public abstract class AlignmentViewport implements AlignViewportI } // common hide/show column stuff - public void hideSelectedColumns() { @@ -628,7 +867,6 @@ public abstract class AlignmentViewport implements AlignViewportI colSel.hideSelectedColumns(); setSelectionGroup(null); - hasHiddenColumns = true; } public void hideColumns(int start, int end) @@ -641,26 +879,19 @@ public abstract class AlignmentViewport implements AlignViewportI { colSel.hideColumns(start, end); } - - hasHiddenColumns = true; } public void showColumn(int col) { colSel.revealHiddenColumns(col); - if (colSel.getHiddenColumns() == null) - { - hasHiddenColumns = false; - } + } public void showAllHiddenColumns() { colSel.revealAllHiddenColumns(); - hasHiddenColumns = false; } - // common hide/show seq stuff public void showAllHiddenSeqs() { @@ -671,11 +902,12 @@ public abstract class AlignmentViewport implements AlignViewportI selectionGroup = new SequenceGroup(); selectionGroup.setEndRes(alignment.getWidth() - 1); } - Vector tmp = alignment.getHiddenSequences().showAll( + List tmp = alignment.getHiddenSequences().showAll( hiddenRepSequences); - for (int t = 0; t < tmp.size(); t++) + for (SequenceI seq : tmp) { - selectionGroup.addSequence((SequenceI) tmp.elementAt(t), false); + selectionGroup.addSequence(seq, false); + setSequenceAnnotationsVisible(seq, true); } hasHiddenRows = false; @@ -690,7 +922,8 @@ public abstract class AlignmentViewport implements AlignViewportI public void showSequence(int index) { - Vector tmp = alignment.getHiddenSequences().showSequence(index, + List tmp = alignment.getHiddenSequences().showSequence( + index, hiddenRepSequences); if (tmp.size() > 0) { @@ -700,9 +933,10 @@ public abstract class AlignmentViewport implements AlignViewportI selectionGroup.setEndRes(alignment.getWidth() - 1); } - for (int t = 0; t < tmp.size(); t++) + for (SequenceI seq : tmp) { - selectionGroup.addSequence((SequenceI) tmp.elementAt(t), false); + selectionGroup.addSequence(seq, false); + setSequenceAnnotationsVisible(seq, true); } // JBPNote: refactor: only update flag if we modified visiblity (used to // do this regardless) @@ -715,8 +949,6 @@ public abstract class AlignmentViewport implements AlignViewportI } } - - public void hideAllSelectedSeqs() { if (selectionGroup == null || selectionGroup.getSize() < 1) @@ -730,7 +962,6 @@ public abstract class AlignmentViewport implements AlignViewportI setSelectionGroup(null); } - public void hideSequence(SequenceI[] seq) { @@ -739,12 +970,30 @@ public abstract class AlignmentViewport implements AlignViewportI for (int i = 0; i < seq.length; i++) { alignment.getHiddenSequences().hideSequence(seq[i]); + setSequenceAnnotationsVisible(seq[i], false); } hasHiddenRows = true; firePropertyChange("alignment", null, alignment.getSequences()); } } + /** + * Set visibility for any annotations for the given sequence. + * + * @param sequenceI + */ + protected void setSequenceAnnotationsVisible(SequenceI sequenceI, + boolean visible) + { + for (AlignmentAnnotation ann : alignment.getAlignmentAnnotation()) + { + if (ann.sequenceRef == sequenceI) + { + ann.visible = visible; + } + } + } + public void hideRepSequences(SequenceI repSequence, SequenceGroup sg) { int sSize = sg.getSize(); @@ -783,8 +1032,8 @@ public abstract class AlignmentViewport implements AlignViewportI public boolean isHiddenRepSequence(SequenceI seq) { - return hiddenRepSequences != null - && hiddenRepSequences.containsKey(seq); + return alignment.getSeqrep()==seq || (hiddenRepSequences != null + && hiddenRepSequences.containsKey(seq)); } public SequenceGroup getRepresentedSequences(SequenceI seq) @@ -793,33 +1042,24 @@ public abstract class AlignmentViewport implements AlignViewportI : hiddenRepSequences.get(seq)); } + @Override public int adjustForHiddenSeqs(int alignmentIndex) { return alignment.getHiddenSequences().adjustForHiddenSeqs( alignmentIndex); } - // Selection manipulation - /** - * broadcast selection to any interested parties - */ + @Override public abstract void sendSelection(); - + @Override public void invertColumnSelection() { colSel.invertColumnSelection(0, alignment.getWidth()); } - /** - * This method returns an array of new SequenceI objects derived from the - * whole alignment or just the current selection with start and end points - * adjusted - * - * @note if you need references to the actual SequenceI objects in the - * alignment or currently selected then use getSequenceSelection() - * @return selection as new sequenceI objects - */ + + @Override public SequenceI[] getSelectionAsNewSequence() { SequenceI[] sequences; @@ -828,7 +1068,7 @@ public abstract class AlignmentViewport implements AlignViewportI // JBPNote: in applet, this method returned references to the alignment // sequences, and it did not honour the presence/absence of annotation // attached to the alignment (probably!) - if (selectionGroup == null) + if (selectionGroup == null || selectionGroup.getSize() == 0) { sequences = alignment.getSequencesArray(); AlignmentAnnotation[] annots = alignment.getAlignmentAnnotation(); @@ -848,12 +1088,8 @@ public abstract class AlignmentViewport implements AlignViewportI return sequences; } - /** - * get the currently selected sequence objects or all the sequences in the - * alignment. - * - * @return array of references to sequence objects - */ + + @Override public SequenceI[] getSequenceSelection() { SequenceI[] sequences = null; @@ -869,64 +1105,34 @@ public abstract class AlignmentViewport implements AlignViewportI } - /** - * This method returns the visible alignment as text, as seen on the GUI, ie - * if columns are hidden they will not be returned in the result. Use this for - * calculating trees, PCA, redundancy etc on views which contain hidden - * columns. - * - * @return String[] - */ + @Override public jalview.datamodel.CigarArray getViewAsCigars( boolean selectedRegionOnly) { - return new jalview.datamodel.CigarArray(alignment, - (hasHiddenColumns ? colSel : null), + return new jalview.datamodel.CigarArray(alignment, colSel, (selectedRegionOnly ? selectionGroup : null)); } - /** - * return a compact representation of the current alignment selection to pass - * to an analysis function - * - * @param selectedOnly - * boolean true to just return the selected view - * @return AlignmentView - */ + + @Override public jalview.datamodel.AlignmentView getAlignmentView( boolean selectedOnly) { return getAlignmentView(selectedOnly, false); } - /** - * return a compact representation of the current alignment selection to pass - * to an analysis function - * - * @param selectedOnly - * boolean true to just return the selected view - * @param markGroups - * boolean true to annotate the alignment view with groups on the - * alignment (and intersecting with selected region if selectedOnly - * is true) - * @return AlignmentView - */ + + @Override public jalview.datamodel.AlignmentView getAlignmentView( boolean selectedOnly, boolean markGroups) { return new AlignmentView(alignment, colSel, selectionGroup, - hasHiddenColumns, selectedOnly, markGroups); + colSel != null && colSel.hasHiddenColumns(), selectedOnly, + markGroups); } - /** - * This method returns the visible alignment as text, as seen on the GUI, ie - * if columns are hidden they will not be returned in the result. Use this for - * calculating trees, PCA, redundancy etc on views which contain hidden - * columns. - * - * @return String[] - */ + @Override public String[] getViewAsString(boolean selectedRegionOnly) { String[] selection = null; @@ -948,7 +1154,7 @@ public abstract class AlignmentViewport implements AlignViewportI } selection = new String[iSize]; - if (hasHiddenColumns) + if (colSel != null && colSel.hasHiddenColumns()) { selection = colSel.getVisibleSequenceStrings(start, end, seqs); } @@ -963,15 +1169,8 @@ public abstract class AlignmentViewport implements AlignViewportI return selection; } - /** - * return visible region boundaries within given column range - * - * @param min - * first column (inclusive, from 0) - * @param max - * last column (exclusive) - * @return int[][] range of {start,end} visible positions - */ + + @Override public int[][] getVisibleRegionBoundaries(int min, int max) { Vector regions = new Vector(); @@ -980,7 +1179,7 @@ public abstract class AlignmentViewport implements AlignViewportI do { - if (hasHiddenColumns) + if (colSel != null && colSel.hasHiddenColumns()) { if (start == 0) { @@ -1001,7 +1200,7 @@ public abstract class AlignmentViewport implements AlignViewportI regions.addElement(new int[] { start, end }); - if (hasHiddenColumns) + if (colSel != null && colSel.hasHiddenColumns()) { start = colSel.adjustForHiddenColumns(end); start = colSel.getHiddenBoundaryLeft(start) + 1; @@ -1015,18 +1214,38 @@ public abstract class AlignmentViewport implements AlignViewportI return startEnd; } - /** - * @return the padGaps - */ + + @Override + public List getVisibleAlignmentAnnotation(boolean selectedOnly) + { + ArrayList ala = new ArrayList(); + AlignmentAnnotation[] aa; + if ((aa=alignment.getAlignmentAnnotation())!=null) + { + for (AlignmentAnnotation annot:aa) + { + AlignmentAnnotation clone = new AlignmentAnnotation(annot); + if (selectedOnly && selectionGroup!=null) + { + colSel.makeVisibleAnnotation(selectionGroup.getStartRes(), selectionGroup.getEndRes(),clone); + } else { + colSel.makeVisibleAnnotation(clone); + } + ala.add(clone); + } + } + return ala; + } + + + @Override public boolean isPadGaps() { return padGaps; } - /** - * @param padGaps - * the padGaps to set - */ + + @Override public void setPadGaps(boolean padGaps) { this.padGaps = padGaps; @@ -1038,6 +1257,7 @@ public abstract class AlignmentViewport implements AlignViewportI * * @param ap */ + @Override public void alignmentChanged(AlignmentViewPanel ap) { if (isPadGaps()) @@ -1059,12 +1279,11 @@ public abstract class AlignmentViewport implements AlignViewportI // Reset endRes of groups if beyond alignment width int alWidth = alignment.getWidth(); - Vector groups = alignment.getGroups(); + List groups = alignment.getGroups(); if (groups != null) { - for (int i = 0; i < groups.size(); i++) + for (SequenceGroup sg : groups) { - SequenceGroup sg = (SequenceGroup) groups.elementAt(i); if (sg.getEndRes() > alWidth) { sg.setEndRes(alWidth - 1); @@ -1082,7 +1301,6 @@ public abstract class AlignmentViewport implements AlignViewportI // alignment.adjustSequenceAnnotations(); } - /** * reset scope and do calculations for all applied colourschemes on alignment */ @@ -1091,13 +1309,7 @@ public abstract class AlignmentViewport implements AlignViewportI ColourSchemeI cs = globalColourScheme; if (cs != null) { - cs.alignmentChanged(alignment); - // TODO: fold all recalc events for clustalX into alignmentChanged - if (cs instanceof ClustalxColourScheme) - { - ((ClustalxColourScheme) cs).resetClustalX(alignment.getSequences(), - alignment.getWidth()); - } + cs.alignmentChanged(alignment, hiddenRepSequences); cs.setConsensus(hconsensus); if (cs.conservationApplied()) @@ -1108,14 +1320,11 @@ public abstract class AlignmentViewport implements AlignViewportI } } - int s, sSize = alignment.getGroups().size(); - for (s = 0; s < sSize; s++) + for (SequenceGroup sg : alignment.getGroups()) { - SequenceGroup sg = (SequenceGroup) alignment.getGroups().elementAt(s); - if (sg.cs != null && sg.cs instanceof ClustalxColourScheme) + if (sg.cs != null) { - ((ClustalxColourScheme) sg.cs).resetClustalX(sg - .getSequences(hiddenRepSequences), sg.getWidth()); + sg.cs.alignmentChanged(sg, hiddenRepSequences); } sg.recalcConservation(); } @@ -1131,60 +1340,389 @@ public abstract class AlignmentViewport implements AlignViewportI { if (!alignment.isNucleotide()) { - if (showConservation) + initConservation(); + initQuality(); + } + else + { + initRNAStructure(); + } + initConsensus(); + } + } + + private void initConsensus() + { + + consensus = new AlignmentAnnotation("Consensus", "PID", + new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH); + consensus.hasText = true; + consensus.autoCalculated = true; + + if (showConsensus) + { + alignment.addAnnotation(consensus); + } + } + + private void initConservation() + { + if (showConservation) + { + if (conservation == null) + { + conservation = new AlignmentAnnotation("Conservation", + "Conservation of total alignment less than " + + getConsPercGaps() + "% gaps", new Annotation[1], + 0f, 11f, AlignmentAnnotation.BAR_GRAPH); + conservation.hasText = true; + conservation.autoCalculated = true; + alignment.addAnnotation(conservation); + } + } + } + + private void initQuality() + { + if (showQuality) + { + if (quality == null) + { + quality = new AlignmentAnnotation("Quality", + "Alignment Quality based on Blosum62 scores", + new Annotation[1], 0f, 11f, AlignmentAnnotation.BAR_GRAPH); + quality.hasText = true; + quality.autoCalculated = true; + alignment.addAnnotation(quality); + } + } + } + + private void initRNAStructure() + { + if (alignment.hasRNAStructure() && strucConsensus == null) + { + strucConsensus = new AlignmentAnnotation("StrucConsensus", "PID", + new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH); + strucConsensus.hasText = true; + strucConsensus.autoCalculated = true; + + if (showConsensus) + { + alignment.addAnnotation(strucConsensus); + } + } + } + + /* + * (non-Javadoc) + * + * @see jalview.api.AlignViewportI#calcPanelHeight() + */ + @Override + public int calcPanelHeight() + { + // setHeight of panels + AlignmentAnnotation[] aa = getAlignment().getAlignmentAnnotation(); + int height = 0; + int charHeight = getCharHeight(); + if (aa != null) + { + BitSet graphgrp = new BitSet(); + for (int i = 0; i < aa.length; i++) + { + if (aa[i] == null) { - if (conservation == null) - { - conservation = new AlignmentAnnotation("Conservation", - "Conservation of total alignment less than " - + getConsPercGaps() + "% gaps", - new Annotation[1], 0f, 11f, - AlignmentAnnotation.BAR_GRAPH); - conservation.hasText = true; - conservation.autoCalculated = true; - alignment.addAnnotation(conservation); - } + System.err.println("Null annotation row: ignoring."); + continue; } - if (showQuality) + if (!aa[i].visible) { - if (quality == null) + continue; + } + if (aa[i].graphGroup > -1) + { + if (graphgrp.get(aa[i].graphGroup)) { - quality = new AlignmentAnnotation("Quality", - "Alignment Quality based on Blosum62 scores", - new Annotation[1], 0f, 11f, - AlignmentAnnotation.BAR_GRAPH); - quality.hasText = true; - quality.autoCalculated = true; - alignment.addAnnotation(quality); + continue; } + else + { + graphgrp.set(aa[i].graphGroup); + } + } + aa[i].height = 0; + + if (aa[i].hasText) + { + aa[i].height += charHeight; + } + + if (aa[i].hasIcons) + { + aa[i].height += 16; + } + + if (aa[i].graph > 0) + { + aa[i].height += aa[i].graphHeight; + } + + if (aa[i].height == 0) + { + aa[i].height = 20; } + + height += aa[i].height; } - else + } + if (height == 0) + { + // set minimum + height = 20; + } + return height; + } + + @Override + public void updateGroupAnnotationSettings(boolean applyGlobalSettings, + boolean preserveNewGroupSettings) + { + boolean updateCalcs = false; + boolean conv = isShowGroupConservation(); + boolean cons = isShowGroupConsensus(); + boolean showprf = isShowSequenceLogo(); + boolean showConsHist = isShowConsensusHistogram(); + boolean normLogo = isNormaliseSequenceLogo(); + + /** + * TODO reorder the annotation rows according to group/sequence ordering on + * alignment + */ + boolean sortg = true; + + // remove old automatic annotation + // add any new annotation + + // intersect alignment annotation with alignment groups + + AlignmentAnnotation[] aan = alignment.getAlignmentAnnotation(); + List oldrfs = new ArrayList(); + if (aan != null) + { + for (int an = 0; an < aan.length; an++) { - if (alignment.hasRNAStructure()) + if (aan[an].autoCalculated && aan[an].groupRef != null) { - strucConsensus = new AlignmentAnnotation("StrucConsensus", "PID", - new Annotation[1], 0f, 100f, - AlignmentAnnotation.BAR_GRAPH); - strucConsensus.hasText = true; - strucConsensus.autoCalculated = true; + oldrfs.add(aan[an].groupRef); + alignment.deleteAnnotation(aan[an], false); } } + } + if (alignment.getGroups() != null) + { + for (SequenceGroup sg : alignment.getGroups()) + { + updateCalcs = false; + if (applyGlobalSettings + || (!preserveNewGroupSettings && !oldrfs.contains(sg))) + { + // set defaults for this group's conservation/consensus + sg.setshowSequenceLogo(showprf); + sg.setShowConsensusHistogram(showConsHist); + sg.setNormaliseSequenceLogo(normLogo); + } + if (conv) + { + updateCalcs = true; + alignment.addAnnotation(sg.getConservationRow(), 0); + } + if (cons) + { + updateCalcs = true; + alignment.addAnnotation(sg.getConsensus(), 0); + } + // refresh the annotation rows + if (updateCalcs) + { + sg.recalcConservation(); + } + } + } + oldrfs.clear(); + } + /** + * show the reference sequence in the alignment view + */ + private boolean displayReferenceSeq=false; + /** + * colour according to the reference sequence defined on the alignment + */ + private boolean colourByReferenceSeq=false; + + @Override + public boolean isDisplayReferenceSeq() + { + return alignment.hasSeqrep() && displayReferenceSeq; + } + + @Override + public void setDisplayReferenceSeq(boolean displayReferenceSeq) + { + this.displayReferenceSeq = displayReferenceSeq; + } + + public boolean isColourByReferenceSeq() + { + return alignment.hasSeqrep() && colourByReferenceSeq; + } + + public void setColourByReferenceSeq(boolean colourByReferenceSeq) + { + this.colourByReferenceSeq = colourByReferenceSeq; + } + + @Override + public Color getSequenceColour(SequenceI seq) + { + Color sqc = Color.white; + if (sequenceColours != null) + { + sqc = (Color) sequenceColours.get(seq); + if (sqc == null) + { + sqc = Color.white; + } + } + return sqc; + } - consensus = new AlignmentAnnotation("Consensus", "PID", - new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH); - consensus.hasText = true; - consensus.autoCalculated = true; + @Override + public void setSequenceColour(SequenceI seq, Color col) + { + if (sequenceColours == null) + { + sequenceColours = new Hashtable(); + } - if (showConsensus) + if (col == null) + { + sequenceColours.remove(seq); + } + else + { + sequenceColours.put(seq, col); + } + } + + @Override + public void updateSequenceIdColours() + { + if (sequenceColours == null) + { + sequenceColours = new Hashtable(); + } + for (SequenceGroup sg : alignment.getGroups()) + { + if (sg.idColour != null) { - alignment.addAnnotation(consensus); - if (strucConsensus != null) + for (SequenceI s : sg.getSequences(getHiddenRepSequences())) { - alignment.addAnnotation(strucConsensus); + sequenceColours.put(s, sg.idColour); } } } } + @Override + public void clearSequenceColours() + { + sequenceColours = null; + }; + + FeaturesDisplayedI featuresDisplayed = null; + + @Override + public FeaturesDisplayedI getFeaturesDisplayed() + { + return featuresDisplayed; + } + + @Override + public void setFeaturesDisplayed(FeaturesDisplayedI featuresDisplayedI) + { + featuresDisplayed = featuresDisplayedI; + } + + @Override + public boolean areFeaturesDisplayed() + { + return featuresDisplayed != null && featuresDisplayed.getRegisterdFeaturesCount()>0; + } + + /** + * display setting for showing/hiding sequence features on alignment view + */ + boolean showSequenceFeatures = false; + + /** + * set the flag + * + * @param b + * features are displayed if true + */ + @Override + public void setShowSequenceFeatures(boolean b) + { + showSequenceFeatures = b; + } + @Override + public boolean isShowSequenceFeatures() + { + return showSequenceFeatures; + } + + boolean showSeqFeaturesHeight; + + @Override + public void setShowSequenceFeaturesHeight(boolean selected) + { + showSeqFeaturesHeight = selected; + } + + @Override + public boolean isShowSequenceFeaturesHeight() + { + return showSeqFeaturesHeight; + } + + private boolean showAnnotation = true; + + private boolean rightAlignIds = false; + + + @Override + public void setShowAnnotation(boolean b) + { + showAnnotation = b; + } + + @Override + public boolean isShowAnnotation() + { + return showAnnotation; + } + + @Override + public boolean isRightAlignIds() + { + return rightAlignIds; + } + + @Override + public void setRightAlignIds(boolean rightAlignIds) + { + this.rightAlignIds = rightAlignIds; + } + }