X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fappletgui%2FAlignViewport.java;h=ff8f7df33959c561cc8eefe9cdd119a15e87edab;hb=a45774ee31d9f35d4eff46d54d7deab719afb092;hp=b48f672e096ce21a7192afd2fd4f6a7cfc26fd8c;hpb=1d317b3f1db74781afb786fb895b3244b14ddf52;p=jalview.git diff --git a/src/jalview/appletgui/AlignViewport.java b/src/jalview/appletgui/AlignViewport.java old mode 100755 new mode 100644 index b48f672..ff8f7df --- a/src/jalview/appletgui/AlignViewport.java +++ b/src/jalview/appletgui/AlignViewport.java @@ -1,22 +1,20 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer - * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle - * - * This program 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 2 - * of the License, or (at your option) any later version. - * - * This program 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 this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7) + * Copyright (C) 2011 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle + * + * 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. + * + * 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 . */ - package jalview.appletgui; import java.util.*; @@ -27,54 +25,80 @@ import jalview.analysis.*; import jalview.bin.*; import jalview.datamodel.*; import jalview.schemes.*; +import jalview.structure.SelectionSource; +import jalview.structure.StructureSelectionManager; +import jalview.structure.VamsasSource; -public class AlignViewport +public class AlignViewport implements SelectionSource, VamsasSource { int startRes; + int endRes; int startSeq; + int endSeq; boolean cursorMode = false; boolean showJVSuffix = true; + boolean showText = true; + boolean showColourText = false; + boolean showBoxes = true; + boolean wrapAlignment = false; + boolean renderGaps = true; + boolean showSequenceFeatures = false; + boolean showAnnotation = true; + boolean showConservation = true; + boolean showQuality = true; + boolean showConsensus = true; + boolean upperCasebold = false; boolean colourAppliesToAllGroups = true; + ColourSchemeI globalColourScheme = null; + boolean conservationColourSelected = false; + boolean abovePIDThreshold = false; SequenceGroup selectionGroup; int charHeight; + int charWidth; + int wrappedWidth; Font font = new Font("SansSerif", Font.PLAIN, 10); + boolean validCharWidth = true; + AlignmentI alignment; ColumnSelection colSel = new ColumnSelection(); int threshold; + int increment; NJTree currentTree = null; boolean scaleAboveWrapped = true; + boolean scaleLeftWrapped = true; + boolean scaleRightWrapped = true; // The following vector holds the features which are @@ -82,35 +106,52 @@ public class AlignViewport public Hashtable featuresDisplayed; boolean hasHiddenColumns = false; + boolean hasHiddenRows = false; + boolean showHiddenMarkers = true; public Hashtable[] hconsensus; + AlignmentAnnotation consensus; + AlignmentAnnotation conservation; + AlignmentAnnotation quality; + AlignmentAnnotation[] groupConsensus; + + AlignmentAnnotation[] groupConservation; + boolean autocalculateConsensus = true; public int ConsPercGaps = 25; // JBPNote : This should be a scalable property! - private java.beans.PropertyChangeSupport changeSupport = new java.beans. - PropertyChangeSupport(this); + private java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport( + this); boolean ignoreGapsInConsensusCalculation = false; - jalview.bin.JalviewLite applet; + public jalview.bin.JalviewLite applet; Hashtable sequenceColours; boolean MAC = false; Stack historyList = new Stack(); + Stack redoList = new Stack(); String sequenceSetID; Hashtable hiddenRepSequences; + + public void finalize() { + applet=null; + quality=null; + alignment=null; + colSel=null; + } public AlignViewport(AlignmentI al, JalviewLite applet) { @@ -120,46 +161,75 @@ public class AlignViewport this.endRes = al.getWidth() - 1; this.startSeq = 0; this.endSeq = al.getHeight() - 1; - setFont(font); - - if (System.getProperty("os.name").startsWith("Mac")) - { - MAC = true; - } - if (applet != null) { - String param = applet.getParameter("showFullId"); + // get the width and height scaling factors if they were specified + String param = applet.getParameter("widthScale"); if (param != null) { - showJVSuffix = Boolean.valueOf(param).booleanValue(); + try + { + widthScale = new Float(param).floatValue(); + } catch (Exception e) + { + } + if (widthScale <= 1.0) + { + System.err + .println("Invalid alignment character width scaling factor (" + + widthScale + "). Ignoring."); + widthScale = 1; + } + if (applet.debug) + { + System.err + .println("Alignment character width scaling factor is now " + + widthScale); + } } - - param = applet.getParameter("showAnnotation"); + param = applet.getParameter("heightScale"); if (param != null) { - showAnnotation = Boolean.valueOf(param).booleanValue(); + try + { + heightScale = new Float(param).floatValue(); + } catch (Exception e) + { + } + if (heightScale <= 1.0) + { + System.err + .println("Invalid alignment character height scaling factor (" + + heightScale + "). Ignoring."); + heightScale = 1; + } + if (applet.debug) + { + System.err + .println("Alignment character height scaling factor is now " + + heightScale); + } } + } + setFont(font); - param = applet.getParameter("showConservation"); - if (param != null) - { - showConservation = Boolean.valueOf(param).booleanValue(); - } + MAC = new jalview.util.Platform().isAMac(); - param = applet.getParameter("showQuality"); - if (param != null) - { - showQuality = Boolean.valueOf(param).booleanValue(); - } + if (applet != null) + { + showJVSuffix = applet.getDefaultParameter("showFullId", showJVSuffix); - param = applet.getParameter("showConsensus"); - if (param != null) - { - showConsensus = Boolean.valueOf(param).booleanValue(); - } + showAnnotation = applet.getDefaultParameter("showAnnotation", showAnnotation); + + showConservation = applet.getDefaultParameter("showConservation", showConservation); + + showQuality = applet.getDefaultParameter("showQuality", showQuality); + + showConsensus = applet.getDefaultParameter("showConsensus", showConsensus); + + showUnconserved = applet.getDefaultParameter("showUnconserved", showUnconserved); - param = applet.getParameter("upperCase"); + String param = applet.getParameter("upperCase"); if (param != null) { if (param.equalsIgnoreCase("bold")) @@ -167,7 +237,19 @@ public class AlignViewport upperCasebold = true; } } - + sortByTree = applet.getDefaultParameter("sortByTree", sortByTree); + + followHighlight = applet.getDefaultParameter("automaticScrolling",followHighlight); + followSelection = followHighlight; + + showSequenceLogo = applet.getDefaultParameter("showSequenceLogo", showSequenceLogo); + + showGroupConsensus = applet.getDefaultParameter("showGroupConsensus", showGroupConsensus); + + showGroupConservation = applet.getDefaultParameter("showGroupConservation", showGroupConservation); + + showConsensusHistogram = applet.getDefaultParameter("showConsensusHistogram", showConsensusHistogram); + } if (applet != null) @@ -185,7 +267,8 @@ public class AlignViewport if (colour != null) { - globalColourScheme = ColourSchemeProperty.getColour(alignment, colour); + globalColourScheme = ColourSchemeProperty.getColour(alignment, + colour); if (globalColourScheme != null) { globalColourScheme.setConsensus(hconsensus); @@ -194,8 +277,8 @@ public class AlignViewport if (applet.getParameter("userDefinedColour") != null) { - ( (UserColourScheme) globalColourScheme).parseAppletParameter( - applet.getParameter("userDefinedColour")); + ((UserColourScheme) globalColourScheme).parseAppletParameter(applet + .getParameter("userDefinedColour")); } } if (hconsensus == null) @@ -203,10 +286,8 @@ public class AlignViewport if (!alignment.isNucleotide()) { conservation = new AlignmentAnnotation("Conservation", - "Conservation of total alignment less than " + - ConsPercGaps + "% gaps", - new Annotation[1], 0f, - 11f, + "Conservation of total alignment less than " + ConsPercGaps + + "% gaps", new Annotation[1], 0f, 11f, AlignmentAnnotation.BAR_GRAPH); conservation.hasText = true; conservation.autoCalculated = true; @@ -220,11 +301,8 @@ public class AlignViewport { quality = new AlignmentAnnotation("Quality", "Alignment Quality based on Blosum62 scores", - new Annotation[1], - 0f, - 11f, - AlignmentAnnotation.BAR_GRAPH); - quality.hasText = false; + new Annotation[1], 0f, 11f, AlignmentAnnotation.BAR_GRAPH); + quality.hasText = true; quality.autoCalculated = true; alignment.addAnnotation(quality); @@ -232,8 +310,7 @@ public class AlignViewport } consensus = new AlignmentAnnotation("Consensus", "PID", - new Annotation[1], 0f, 100f, - AlignmentAnnotation.BAR_GRAPH); + new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH); consensus.hasText = true; consensus.autoCalculated = true; @@ -255,10 +332,10 @@ public class AlignViewport return showSequenceFeatures; } - class ConservationThread - extends Thread + class ConservationThread extends Thread { AlignmentPanel ap; + public ConservationThread(AlignmentPanel ap) { this.ap = ap; @@ -276,11 +353,10 @@ public class AlignViewport { if (ap != null) { - ap.paintAlignment(true); + ap.paintAlignment(false); } Thread.sleep(200); - } - catch (Exception ex) + } catch (Exception ex) { ex.printStackTrace(); } @@ -288,15 +364,17 @@ public class AlignViewport UPDATING_CONSERVATION = true; - int alWidth = alignment.getWidth(); + int alWidth = (alignment==null) ? -1 : alignment.getWidth(); if (alWidth < 0) { + updatingConservation = false; + UPDATING_CONSERVATION = false; return; } Conservation cons = new jalview.analysis.Conservation("All", - jalview.schemes.ResidueProperties.propHash, 3, - alignment.getSequences(), 0, alWidth - 1); + jalview.schemes.ResidueProperties.propHash, 3, + alignment.getSequences(), 0, alWidth - 1); cons.calculate(); cons.verdict(false, ConsPercGaps); @@ -318,7 +396,8 @@ public class AlignViewport minB = 0f; maxR = 1.0f - minR; maxG = 0.9f - minG; - maxB = 0f - minB; // scalable range for colouring both Conservation and Quality + maxB = 0f - minB; // scalable range for colouring both Conservation and + // Quality float min = 0f; float max = 11f; @@ -355,32 +434,28 @@ public class AlignViewport { value = 10; } - + // TODO - refactor to use a graduatedColorScheme to calculate the + // histogram colors. float vprop = value - min; vprop /= max; - conservation.annotations[i] = - new Annotation(String.valueOf(c), - String.valueOf(value), ' ', value, - new Color(minR + (maxR * vprop), - minG + (maxG * vprop), - minB + (maxB * vprop))); + conservation.annotations[i] = new Annotation(String.valueOf(c), + String.valueOf(value), ' ', value, new Color(minR + + (maxR * vprop), minG + (maxG * vprop), minB + + (maxB * vprop))); // Quality calc if (quality != null) { - value = ( (Double) cons.quality.elementAt(i)).floatValue(); + value = ((Double) cons.quality.elementAt(i)).floatValue(); vprop = value - qmin; vprop /= qmax; - quality.annotations[i] = new Annotation(" ", String.valueOf(value), - ' ', - value, - new Color(minR + (maxR * vprop), - minG + (maxG * vprop), - minB + (maxB * vprop))); + quality.annotations[i] = new Annotation(" ", + String.valueOf(value), ' ', value, new Color(minR + + (maxR * vprop), minG + (maxG * vprop), minB + + (maxB * vprop))); } } - } - catch (OutOfMemoryError error) + } catch (OutOfMemoryError error) { System.out.println("Out of memory calculating conservation!!"); conservation = null; @@ -436,10 +511,10 @@ public class AlignViewport consensusThread.start(); } - class ConsensusThread - extends Thread + class ConsensusThread extends Thread { AlignmentPanel ap; + public ConsensusThread(AlignmentPanel ap) { this.ap = ap; @@ -454,12 +529,11 @@ public class AlignViewport { if (ap != null) { - ap.paintAlignment(true); + ap.paintAlignment(false); } Thread.sleep(200); - } - catch (Exception ex) + } catch (Exception ex) { ex.printStackTrace(); } @@ -469,9 +543,11 @@ public class AlignViewport try { - int aWidth = alignment.getWidth(); + int aWidth = alignment==null ? -1 : alignment.getWidth(); if (aWidth < 0) { + UPDATING_CONSENSUS = false; + updatingConsensus = false; return; } @@ -479,46 +555,20 @@ public class AlignViewport consensus.annotations = new Annotation[aWidth]; hconsensus = new Hashtable[aWidth]; - AAFrequency.calculate(alignment.getSequencesArray(), - 0, - alignment.getWidth(), - hconsensus); - - for (int i = 0; i < aWidth; i++) - { - float value = 0; - if (ignoreGapsInConsensusCalculation) - { - value = ( (Float) hconsensus[i].get(AAFrequency.PID_NOGAPS)). - floatValue(); - } - else - { - value = ( (Float) hconsensus[i].get(AAFrequency.PID_GAPS)). - floatValue(); - } - - String maxRes = hconsensus[i].get(AAFrequency.MAXRESIDUE).toString(); - String mouseOver = hconsensus[i].get(AAFrequency.MAXRESIDUE) + " "; - - if (maxRes.length() > 1) - { - mouseOver = "[" + maxRes + "] "; - maxRes = "+"; - } - - mouseOver += ( (int) value + "%"); - consensus.annotations[i] = new Annotation(maxRes, mouseOver, ' ', - value); - } - + AAFrequency.calculate(alignment.getSequencesArray(), 0, + alignment.getWidth(), hconsensus, true); // always calculate the + // full profile + updateAnnotation(true); + //AAFrequency.completeConsensus(consensus, hconsensus, 0, aWidth, + // ignoreGapsInConsensusCalculation, + // true); + if (globalColourScheme != null) { globalColourScheme.setConsensus(hconsensus); } - } - catch (OutOfMemoryError error) + } catch (OutOfMemoryError error) { alignment.deleteAnnotation(consensus); @@ -535,20 +585,44 @@ public class AlignViewport ap.paintAlignment(true); } } + + /** + * update the consensus annotation from the sequence profile data using + * current visualization settings. + */ + public void updateAnnotation() + { + updateAnnotation(false); + } + + protected void updateAnnotation(boolean immediate) + { + // TODO: make calls thread-safe, so if another thread calls this method, + // it will either return or wait until one calculation is finished. + if (immediate + || (!updatingConsensus && consensus != null && hconsensus != null)) + { + AAFrequency.completeConsensus(consensus, hconsensus, 0, + hconsensus.length, ignoreGapsInConsensusCalculation, + showSequenceLogo); + } + } } /** - * get the consensus sequence as displayed under the PID consensus annotation row. - * @return consensus sequence as a new sequence object - */ - /** - * get the consensus sequence as displayed under the PID consensus annotation row. + * get the consensus sequence as displayed under the PID consensus annotation + * row. + * * @return consensus sequence as a new sequence object */ public SequenceI getConsensusSeq() { if (consensus == null) { + updateConsensus(null); + } + if (consensus == null) + { return null; } StringBuffer seqs = new StringBuffer(); @@ -567,9 +641,8 @@ public class AlignViewport } } SequenceI sq = new Sequence("Consensus", seqs.toString()); - sq.setDescription("Percentage Identity Consensus " + - ( (ignoreGapsInConsensusCalculation) ? " without gaps" : - "")); + sq.setDescription("Percentage Identity Consensus " + + ((ignoreGapsInConsensusCalculation) ? " without gaps" : "")); return sq; } @@ -642,7 +715,8 @@ public class AlignViewport { if (res > alignment.getWidth() - 1) { - // log.System.out.println(" Corrected res from " + res + " to maximum " + (alignment.getWidth()-1)); + // log.System.out.println(" Corrected res from " + res + " to maximum " + + // (alignment.getWidth()-1)); res = alignment.getWidth() - 1; } if (res < 0) @@ -671,6 +745,11 @@ public class AlignViewport } java.awt.Frame nullFrame; + + protected FeatureSettings featureSettings = null; + + private float heightScale = 1, widthScale = 1; + public void setFont(Font f) { font = f; @@ -681,14 +760,14 @@ public class AlignViewport } java.awt.FontMetrics fm = nullFrame.getGraphics().getFontMetrics(font); - setCharHeight(fm.getHeight()); - charWidth = fm.charWidth('M'); + setCharHeight((int) (heightScale * fm.getHeight())); + charWidth = (int) (widthScale * fm.charWidth('M')); if (upperCasebold) { Font f2 = new Font(f.getName(), Font.BOLD, f.getSize()); fm = nullFrame.getGraphics().getFontMetrics(f2); - charWidth = fm.stringWidth("MMMMMMMMMMM") / 10; + charWidth = (int) (widthScale * (fm.stringWidth("MMMMMMMMMMM") / 10)); } } @@ -906,41 +985,47 @@ public class AlignViewport if (globalColourScheme != null) { globalColourScheme.setThreshold(globalColourScheme.getThreshold(), - ignoreGapsInConsensusCalculation); + ignoreGapsInConsensusCalculation); } } /** * Property change listener for changes in alignment - * - * @param listener DOCUMENT ME! + * + * @param listener + * DOCUMENT ME! */ public void addPropertyChangeListener( - java.beans.PropertyChangeListener listener) + java.beans.PropertyChangeListener listener) { changeSupport.addPropertyChangeListener(listener); } /** * DOCUMENT ME! - * - * @param listener DOCUMENT ME! + * + * @param listener + * DOCUMENT ME! */ public void removePropertyChangeListener( - java.beans.PropertyChangeListener listener) + java.beans.PropertyChangeListener listener) { changeSupport.removePropertyChangeListener(listener); } /** * Property change listener for changes in alignment - * - * @param prop DOCUMENT ME! - * @param oldvalue DOCUMENT ME! - * @param newvalue DOCUMENT ME! + * + * @param prop + * DOCUMENT ME! + * @param oldvalue + * DOCUMENT ME! + * @param newvalue + * DOCUMENT ME! */ - public void firePropertyChange(String prop, Object oldvalue, Object newvalue) + public void firePropertyChange(String prop, Object oldvalue, + Object newvalue) { changeSupport.firePropertyChange(prop, oldvalue, newvalue); } @@ -1010,7 +1095,7 @@ public class AlignViewport hiddenRepSequences.put(repSequence, sg); - //Hide all sequences except the repSequence + // Hide all sequences except the repSequence SequenceI[] seqs = new SequenceI[sSize - 1]; int index = 0; for (int i = 0; i < sSize; i++) @@ -1032,7 +1117,7 @@ public class AlignViewport public void hideAllSelectedSeqs() { - if (selectionGroup == null || selectionGroup.getSize()<1) + if (selectionGroup == null || selectionGroup.getSize() < 1) { return; } @@ -1057,7 +1142,31 @@ public class AlignViewport firePropertyChange("alignment", null, alignment.getSequences()); } } + public void showSequence(int index) + { + Vector tmp = alignment.getHiddenSequences().showSequence(index, + hiddenRepSequences); + if (tmp.size() > 0) + { + if (selectionGroup == null) + { + selectionGroup = new SequenceGroup(); + selectionGroup.setEndRes(alignment.getWidth() - 1); + } + for (int t = 0; t < tmp.size(); t++) + { + selectionGroup.addSequence((SequenceI) tmp.elementAt(t), false); + } + firePropertyChange("alignment", null, alignment.getSequences()); + sendSelection(); + } + + if (alignment.getHiddenSequences().getSize() < 1) + { + hasHiddenRows = false; + } + } public void showColumn(int col) { colSel.revealHiddenColumns(col); @@ -1082,27 +1191,29 @@ public class AlignViewport selectionGroup = new SequenceGroup(); selectionGroup.setEndRes(alignment.getWidth() - 1); } - Vector tmp = alignment.getHiddenSequences().showAll(hiddenRepSequences); + Vector tmp = alignment.getHiddenSequences().showAll( + hiddenRepSequences); for (int t = 0; t < tmp.size(); t++) { - selectionGroup.addSequence( - (SequenceI) tmp.elementAt(t), false - ); + selectionGroup.addSequence((SequenceI) tmp.elementAt(t), false); } firePropertyChange("alignment", null, alignment.getSequences()); hasHiddenRows = false; hiddenRepSequences = null; + sendSelection(); } } public int adjustForHiddenSeqs(int alignmentIndex) { - return alignment.getHiddenSequences().adjustForHiddenSeqs(alignmentIndex); + return alignment.getHiddenSequences().adjustForHiddenSeqs( + alignmentIndex); } /** - * This method returns the a new SequenceI [] with - * the selection sequence and start and end points adjusted + * This method returns the a new SequenceI [] with the selection sequence and + * start and end points adjusted + * * @return String[] */ public SequenceI[] getSelectionAsNewSequence() @@ -1122,129 +1233,72 @@ public class AlignViewport } /** - * 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[] + * get the currently selected sequence objects or all the sequences in the + * alignment. + * + * @return array of references to sequence objects */ - public jalview.datamodel.CigarArray getViewAsCigars(boolean - selectedRegionOnly) + public SequenceI[] getSequenceSelection() { - CigarArray selection = null; - SequenceI[] seqs = null; - int i, iSize; - int start = 0, end = 0; - if (selectedRegionOnly && selectionGroup != null) + SequenceI[] sequences = null; + if (selectionGroup != null) { - iSize = selectionGroup.getSize(); - seqs = selectionGroup.getSequencesInOrder(alignment); - start = selectionGroup.getStartRes(); - end = selectionGroup.getEndRes(); // inclusive for start and end in SeqCigar constructor + sequences = selectionGroup.getSequencesInOrder(alignment); } - else + if (sequences == null) { - iSize = alignment.getHeight(); - seqs = alignment.getSequencesArray(); - end = alignment.getWidth() - 1; - } - SeqCigar[] selseqs = new SeqCigar[iSize]; - for (i = 0; i < iSize; i++) - { - selseqs[i] = new SeqCigar(seqs[i], start, end); + sequences = alignment.getSequencesArray(); } - selection = new CigarArray(selseqs); - // now construct the CigarArray operations - if (hasHiddenColumns) - { - Vector regions = colSel.getHiddenColumns(); - int[] region; - int hideStart, hideEnd; - int last = start; - for (int j = 0; last < end & j < regions.size(); j++) - { - region = (int[]) regions.elementAt(j); - hideStart = region[0]; - hideEnd = region[1]; - // edit hidden regions to selection range - if (hideStart < last) - { - if (hideEnd > last) - { - hideStart = last; - } - else - { - continue; - } - } - - if (hideStart > end) - { - break; - } - - if (hideEnd > end) - { - hideEnd = end; - } + return sequences; + } - if (hideStart > hideEnd) - { - break; - } - /** - * form operations... - */ - if (last < hideStart) - { - selection.addOperation(CigarArray.M, hideStart - last); - } - selection.addOperation(CigarArray.D, 1 + hideEnd - hideStart); - last = hideEnd + 1; - } - // Final match if necessary. - if (last < end) - { - selection.addOperation(CigarArray.M, end - last + 1); - } - } - else - { - selection.addOperation(CigarArray.M, end - start + 1); - } - return selection; + /** + * 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[] + */ + public jalview.datamodel.CigarArray getViewAsCigars( + boolean selectedRegionOnly) + { + return new jalview.datamodel.CigarArray(alignment, (hasHiddenColumns ? colSel : null), (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 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 */ 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 + */ + public jalview.datamodel.AlignmentView getAlignmentView(boolean selectedOnly, boolean markGroups) { - // JBPNote: - // this is here because the AlignmentView constructor modifies the CigarArray - // object. Refactoring of Cigar and alignment view representation should - // be done to remove redundancy. - CigarArray aligview = getViewAsCigars(selectedOnly); - if (aligview != null) - { - return new AlignmentView(aligview, - (selectedOnly && selectionGroup != null) ? - selectionGroup.getStartRes() : 0); - } - return null; + return new AlignmentView(alignment, colSel, selectionGroup, 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. + * 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[] */ public String[] getViewAsString(boolean selectedRegionOnly) @@ -1369,6 +1423,20 @@ public class AlignViewport return sequenceSetID; } + /** + * unique viewId for synchronizing state (e.g. with stored Jalview Project) + * + */ + private String viewId = null; + + public String getViewId() + { + if (viewId == null) + { + viewId = this.getSequenceSetId() + "." + this.hashCode() + ""; + } + return viewId; + } public void alignmentChanged(AlignmentPanel ap) { @@ -1380,7 +1448,7 @@ public class AlignViewport updateConservation(ap); } - //Reset endRes of groups if beyond alignment width + // Reset endRes of groups if beyond alignment width int alWidth = alignment.getWidth(); Vector groups = alignment.getGroups(); if (groups != null) @@ -1402,7 +1470,7 @@ public class AlignViewport resetAllColourSchemes(); - //AW alignment.adjustSequenceAnnotations(); + // AW alignment.adjustSequenceAnnotations(); } void resetAllColourSchemes() @@ -1412,9 +1480,8 @@ public class AlignViewport { if (cs instanceof ClustalxColourScheme) { - ( (ClustalxColourScheme) cs). - resetClustalX(alignment.getSequences(), - alignment.getWidth()); + ((ClustalxColourScheme) cs).resetClustalX(alignment.getSequences(), + alignment.getWidth()); } cs.setConsensus(hconsensus); @@ -1422,9 +1489,8 @@ public class AlignViewport { Alignment al = (Alignment) alignment; Conservation c = new Conservation("All", - ResidueProperties.propHash, 3, - al.getSequences(), 0, - al.getWidth() - 1); + ResidueProperties.propHash, 3, al.getSequences(), 0, + al.getWidth() - 1); c.calculate(); c.verdict(false, ConsPercGaps); @@ -1438,11 +1504,258 @@ public class AlignViewport SequenceGroup sg = (SequenceGroup) alignment.getGroups().elementAt(s); if (sg.cs != null && sg.cs instanceof ClustalxColourScheme) { - ( (ClustalxColourScheme) sg.cs).resetClustalX( - sg.getSequences(hiddenRepSequences), sg.getWidth()); + ((ClustalxColourScheme) sg.cs).resetClustalX( + sg.getSequences(hiddenRepSequences), sg.getWidth()); } sg.recalcConservation(); } } + boolean centreColumnLabels; + + public boolean getCentreColumnLabels() + { + return centreColumnLabels; + } + + public void updateSequenceIdColours() + { + Vector groups = alignment.getGroups(); + for (int ig = 0, igSize = groups.size(); ig < igSize; ig++) + { + SequenceGroup sg = (SequenceGroup) groups.elementAt(ig); + if (sg.idColour != null) + { + Vector sqs = sg.getSequences(hiddenRepSequences); + for (int s = 0, sSize = sqs.size(); s < sSize; s++) + { + this.setSequenceColour((SequenceI) sqs.elementAt(s), sg.idColour); + } + } + } + } + + public boolean followHighlight = true; + + public boolean getFollowHighlight() + { + return followHighlight; + } + + public boolean followSelection = true; + + /** + * @return true if view selection should always follow the selections + * broadcast by other selection sources + */ + public boolean getFollowSelection() + { + return followSelection; + } + + private long sgrouphash = -1, colselhash = -1; + + /** + * checks current SelectionGroup against record of last hash value, and + * updates record. + * + * @return true if SelectionGroup changed since last call + */ + boolean isSelectionGroupChanged() + { + int hc = (selectionGroup == null) ? -1 : selectionGroup.hashCode(); + if (hc != sgrouphash) + { + sgrouphash = hc; + return true; + } + return false; + } + + /** + * checks current colsel against record of last hash value, and updates + * record. + * + * @return true if colsel changed since last call + */ + boolean isColSelChanged() + { + int hc = (colSel == null) ? -1 : colSel.hashCode(); + if (hc != colselhash) + { + colselhash = hc; + return true; + } + return false; + } + public void sendSelection() + { + jalview.structure.StructureSelectionManager + .getStructureSelectionManager(applet).sendSelection( + new SequenceGroup(getSelectionGroup()), + new ColumnSelection(getColumnSelection()), this); + } + + + + + /** + * show non-conserved residues only + */ + public boolean showUnconserved = false; + + /** + * when set, alignment should be reordered according to a newly opened tree + */ + public boolean sortByTree = false; + + /** + * @return the showUnconserved + */ + public boolean getShowunconserved() + { + return showUnconserved; + } + + /** + * @param showNonconserved + * the showUnconserved to set + */ + public void setShowunconserved(boolean displayNonconserved) + { + this.showUnconserved = displayNonconserved; + } + + /** + * should conservation rows be shown for groups + */ + boolean showGroupConservation = false; + + /** + * should consensus rows be shown for groups + */ + boolean showGroupConsensus = false; + + /** + * should consensus profile be rendered by default + */ + public boolean showSequenceLogo = false; + + /** + * should consensus histograms be rendered by default + */ + public boolean showConsensusHistogram = true; + + /** + * @return the showConsensusProfile + */ + public boolean isShowSequenceLogo() + { + return showSequenceLogo; + } + + /** + * @param showSequenceLogo + * the new value + */ + public void setShowSequenceLogo(boolean showSequenceLogo) + { + if (showSequenceLogo != this.showSequenceLogo) + { + // TODO: decouple settings setting from calculation when refactoring + // annotation update method from alignframe to viewport + this.showSequenceLogo = showSequenceLogo; + if (consensusThread != null) + { + consensusThread.updateAnnotation(); + } + } + this.showSequenceLogo = showSequenceLogo; + } + + /** + * @param showConsensusHistogram + * the showConsensusHistogram to set + */ + public void setShowConsensusHistogram(boolean showConsensusHistogram) + { + this.showConsensusHistogram = showConsensusHistogram; + } + + /** + * @return the showGroupConservation + */ + public boolean isShowGroupConservation() + { + return showGroupConservation; + } + + /** + * @param showGroupConservation + * the showGroupConservation to set + */ + public void setShowGroupConservation(boolean showGroupConservation) + { + this.showGroupConservation = showGroupConservation; + } + + /** + * @return the showGroupConsensus + */ + public boolean isShowGroupConsensus() + { + return showGroupConsensus; + } + + /** + * @param showGroupConsensus + * the showGroupConsensus to set + */ + public void setShowGroupConsensus(boolean showGroupConsensus) + { + this.showGroupConsensus = showGroupConsensus; + } + + /** + * + * @return flag to indicate if the consensus histogram should be rendered by + * default + */ + public boolean isShowConsensusHistogram() + { + return this.showConsensusHistogram; + } + + /** + * synthesize a column selection if none exists so it covers the given + * selection group. if wholewidth is false, no column selection is made if the + * selection group covers the whole alignment width. + * + * @param sg + * @param wholewidth + */ + public void expandColSelection(SequenceGroup sg, boolean wholewidth) + { + int sgs, sge; + if (sg != null + && (sgs = sg.getStartRes()) >= 0 + && sg.getStartRes() <= (sge = sg.getEndRes()) + && (colSel == null || colSel.getSelected() == null || colSel + .getSelected().size() == 0)) + { + if (!wholewidth && alignment.getWidth() == (1 + sge - sgs)) + { + // do nothing + return; + } + if (colSel == null) + { + colSel = new ColumnSelection(); + } + for (int cspos = sg.getStartRes(); cspos <= sg.getEndRes(); cspos++) + { + colSel.addElement(cspos); + } + } + } }