X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fappletgui%2FAlignViewport.java;h=e981e4fb615ec82ffcdc2feac0484cc977250d99;hb=93642d621a7f86318a7777b0a70f6113dcd299dc;hp=e5551e2c094eddb78a5db02df1185cefbbe57190;hpb=6366cf9dcc083ef36aa9fe822bf49fbc18100dca;p=jalview.git diff --git a/src/jalview/appletgui/AlignViewport.java b/src/jalview/appletgui/AlignViewport.java index e5551e2..e981e4f 100755 --- 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.5.1) + * Copyright (C) 2010 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.*; @@ -31,50 +29,73 @@ import jalview.schemes.*; public class AlignViewport { 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,20 +103,29 @@ 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; @@ -106,6 +136,7 @@ public class AlignViewport boolean MAC = false; Stack historyList = new Stack(); + Stack redoList = new Stack(); String sequenceSetID; @@ -120,12 +151,59 @@ 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")) + if (applet != null) { - MAC = true; + // get the width and height scaling factors if they were specified + String param = applet.getParameter("widthScale"); + if (param != null) + { + 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("heightScale"); + if (param != null) + { + 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); + + MAC = new jalview.util.Platform().isAMac(); if (applet != null) { @@ -159,6 +237,12 @@ public class AlignViewport showConsensus = Boolean.valueOf(param).booleanValue(); } + param = applet.getParameter("showUnconserved"); + if (param != null) + { + this.showUnconserved = Boolean.valueOf(param).booleanValue(); + } + param = applet.getParameter("upperCase"); if (param != null) { @@ -167,6 +251,11 @@ public class AlignViewport upperCasebold = true; } } + param = applet.getParameter("sortByTree"); + if (param != null) + { + sortByTree = Boolean.valueOf(param).booleanValue(); + } } @@ -185,7 +274,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 +284,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,37 +293,31 @@ 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; - + if (showConservation) { alignment.addAnnotation(conservation); } - + if (showQuality) { quality = new AlignmentAnnotation("Quality", "Alignment Quality based on Blosum62 scores", - new Annotation[1], - 0f, - 11f, - AlignmentAnnotation.BAR_GRAPH); + new Annotation[1], 0f, 11f, AlignmentAnnotation.BAR_GRAPH); quality.hasText = true; quality.autoCalculated = true; - + alignment.addAnnotation(quality); } } - + 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; @@ -242,7 +326,7 @@ public class AlignViewport alignment.addAnnotation(consensus); } } - + } public void showSequenceFeatures(boolean b) @@ -255,10 +339,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 +360,10 @@ public class AlignViewport { if (ap != null) { - ap.paintAlignment(true); + ap.paintAlignment(false); } Thread.sleep(200); - } - catch (Exception ex) + } catch (Exception ex) { ex.printStackTrace(); } @@ -295,8 +378,8 @@ public class AlignViewport } 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 +401,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 +439,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 +516,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 +534,11 @@ public class AlignViewport { if (ap != null) { - ap.paintAlignment(true); + ap.paintAlignment(false); } Thread.sleep(200); - } - catch (Exception ex) + } catch (Exception ex) { ex.printStackTrace(); } @@ -479,46 +558,18 @@ 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 + AAFrequency.completeConsensus(consensus, hconsensus, 0, aWidth, + ignoreGapsInConsensusCalculation, + includeAllConsensusSymbols); if (globalColourScheme != null) { globalColourScheme.setConsensus(hconsensus); } - } - catch (OutOfMemoryError error) + } catch (OutOfMemoryError error) { alignment.deleteAnnotation(consensus); @@ -538,11 +589,9 @@ public class AlignViewport } /** - * 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() @@ -567,9 +616,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 +690,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 +720,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 +735,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 +960,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 +1070,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 +1092,7 @@ public class AlignViewport public void hideAllSelectedSeqs() { - if (selectionGroup == null || selectionGroup.getSize()<1) + if (selectionGroup == null || selectionGroup.getSize() < 1) { return; } @@ -1082,12 +1142,11 @@ 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; @@ -1097,12 +1156,14 @@ public class AlignViewport 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,15 +1183,35 @@ 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. + * get the currently selected sequence objects or all the sequences in the + * alignment. + * + * @return array of references to sequence objects + */ + public SequenceI[] getSequenceSelection() + { + SequenceI[] sequences = null; + if (selectionGroup != null) + { + sequences = selectionGroup.getSequencesInOrder(alignment); + } + if (sequences == null) + { + sequences = alignment.getSequencesArray(); + } + return sequences; + } + + /** + * 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) + public jalview.datamodel.CigarArray getViewAsCigars( + boolean selectedRegionOnly) { CigarArray selection = null; SequenceI[] seqs = null; @@ -1141,7 +1222,8 @@ public class AlignViewport iSize = selectionGroup.getSize(); seqs = selectionGroup.getSequencesInOrder(alignment); start = selectionGroup.getStartRes(); - end = selectionGroup.getEndRes(); // inclusive for start and end in SeqCigar constructor + end = selectionGroup.getEndRes(); // inclusive for start and end in + // SeqCigar constructor } else { @@ -1218,33 +1300,36 @@ public class AlignViewport } /** - * 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) { // JBPNote: - // this is here because the AlignmentView constructor modifies the CigarArray + // 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); + (selectedOnly && selectionGroup != null) ? selectionGroup + .getStartRes() : 0); } return null; } /** - * 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) @@ -1380,7 +1465,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 +1487,7 @@ public class AlignViewport resetAllColourSchemes(); - //AW alignment.adjustSequenceAnnotations(); + // AW alignment.adjustSequenceAnnotations(); } void resetAllColourSchemes() @@ -1412,9 +1497,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 +1506,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 +1521,172 @@ 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 = false; + + public boolean getFollowHighlight() + { + return followHighlight; + } + + /** + * 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; + } + + /** + * consensus annotation includes all percentage for all symbols in column + * DISABLED FOR 2.5 RELEASE (bug #60064 logo rendering is not AWT 1.1 + * compatible) + */ + private boolean includeAllConsensusSymbols = false; + + /** + * should conservation rows be shown for groups DISABLED FOR 2.5 RELEASE (bug + * 62446) + */ + boolean showGroupConservation = false; + + /** + * should consensus rows be shown for groups DISABLED FOR 2.5 RELEASE (bug + * 62446) + */ + boolean showGroupConsensus = false; + + /** + * should consensus profile be rendered by default DISABLED FOR 2.5 RELEASE + * (bug #60064 logo rendering is not AWT 1.1 compatible) + */ + 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) { this.showSequenceLogo = showSequenceLogo; } + */ + /** + * @param showGroupConsensus + * the showGroupConsensus to set + */ + public void setShowGroupConsensus(boolean showGroupConsensus) + { + this.showGroupConsensus = showGroupConsensus; + } + + /** + * @return the includeAllConsensusSymbols + */ + public boolean isIncludeAllConsensusSymbols() + { + return false; + } + + /** + * + * @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); + } + } + } + }