X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fio%2FAnnotationFile.java;h=00b7ead85bde0ac4d6b5c104d33c3752c971904f;hb=96f41aa46d3e568f8734834ab36fdc9ad8e54ac1;hp=288ce2fc0a14df4d30c7f285e800bf4146d6b604;hpb=35a5186a5d49868d70138aab55dfd284119914f4;p=jalview.git diff --git a/src/jalview/io/AnnotationFile.java b/src/jalview/io/AnnotationFile.java index 288ce2f..00b7ead 100755 --- a/src/jalview/io/AnnotationFile.java +++ b/src/jalview/io/AnnotationFile.java @@ -1,22 +1,21 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer - * Copyright (C) 2007 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle - * + * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1) + * Copyright (C) 2009 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 */ - package jalview.io; import java.io.*; @@ -29,46 +28,62 @@ import jalview.schemes.*; public class AnnotationFile { - StringBuffer text = new StringBuffer( - "JALVIEW_ANNOTATION\n" - + "# Created: " - + new java.util.Date() + "\n\n"); + StringBuffer text = new StringBuffer("JALVIEW_ANNOTATION\n" + + "# Created: " + new java.util.Date() + "\n\n"); + /** - * convenience method for pre-2.4 feature files which have no view, hidden columns or hidden row keywords. + * convenience method for pre-2.4 feature files which have no view, hidden + * columns or hidden row keywords. + * * @param annotations * @param groups * @param properties * @return feature file as a string. */ public String printAnnotations(AlignmentAnnotation[] annotations, - Vector groups, - Hashtable properties) + Vector groups, Hashtable properties) { - return printAnnotations(annotations, groups, - properties, null); + return printAnnotations(annotations, groups, properties, null); } + /** - * hold all the information about a particular view definition - * read from or written out in an annotations file. + * hold all the information about a particular view definition read from or + * written out in an annotations file. */ - public class ViewDef { + public class ViewDef + { public String viewname; + public HiddenSequences hidseqs; + public ColumnSelection hiddencols; + public Vector visibleGroups; + + public Hashtable hiddenRepSeqs; + public ViewDef(String viewname, HiddenSequences hidseqs, - ColumnSelection hiddencols) + ColumnSelection hiddencols, Hashtable hiddenRepSeqs) { this.viewname = viewname; this.hidseqs = hidseqs; this.hiddencols = hiddencols; + this.hiddenRepSeqs = hiddenRepSeqs; } } + /** + * Prepare an annotation file given a set of annotations, groups, alignment properties and views. + * @param annotations + * @param groups + * @param properties + * @param views + * @return annotation file + */ public String printAnnotations(AlignmentAnnotation[] annotations, - Vector groups, - Hashtable properties, ViewDef[] views) + Vector groups, Hashtable properties, ViewDef[] views) { + // TODO: resolve views issue : annotationFile could contain visible region, or full data + hidden region specifications for a view. if (annotations != null) { boolean oneColour = true; @@ -78,7 +93,7 @@ public class AnnotationFile StringBuffer colours = new StringBuffer(); StringBuffer graphLine = new StringBuffer(); - + StringBuffer rowprops = new StringBuffer(); Hashtable graphGroup = new Hashtable(); java.awt.Color color; @@ -110,31 +125,58 @@ public class AnnotationFile refSeq = row.sequenceRef; text.append("\nSEQUENCE_REF\t" + refSeq.getName() + "\n"); } + boolean hasGlyphs = false, hasLabels = false, hasValues = false, hasText = false; + // lookahead to check what the annotation row object actually contains. + for (int j = 0; row.annotations != null + && j < row.annotations.length + && (!hasGlyphs || !hasLabels || !hasValues); j++) + { + if (row.annotations[j] != null) + { + hasLabels |= (row.annotations[j].displayCharacter != null + && row.annotations[j].displayCharacter.length() > 0 && !row.annotations[j].displayCharacter + .equals(" ")); + hasGlyphs |= (row.annotations[j].secondaryStructure != 0 && row.annotations[j].secondaryStructure != ' '); + hasValues |= (row.annotations[j].value != Float.NaN); // NaNs can't + // be + // rendered.. + hasText |= (row.annotations[j].description != null && row.annotations[j].description + .length() > 0); + } + } if (row.graph == AlignmentAnnotation.NO_GRAPH) { text.append("NO_GRAPH\t"); + hasValues = false; // only secondary structure + // hasLabels = false; // and annotation description string. } else { if (row.graph == AlignmentAnnotation.BAR_GRAPH) { text.append("BAR_GRAPH\t"); + hasGlyphs = false; // no secondary structure + } else if (row.graph == AlignmentAnnotation.LINE_GRAPH) { + hasGlyphs = false; // no secondary structure text.append("LINE_GRAPH\t"); } if (row.getThreshold() != null) { - graphLine.append("GRAPHLINE\t" - + row.label + "\t" - + row.getThreshold().value + "\t" - + row.getThreshold().label + "\t" - + jalview.util.Format.getHexString( - row.getThreshold().colour) + "\n" - ); + graphLine + .append("GRAPHLINE\t" + + row.label + + "\t" + + row.getThreshold().value + + "\t" + + row.getThreshold().label + + "\t" + + jalview.util.Format.getHexString(row + .getThreshold().colour) + "\n"); } if (row.graphGroup > -1) @@ -142,8 +184,7 @@ public class AnnotationFile String key = String.valueOf(row.graphGroup); if (graphGroup.containsKey(key)) { - graphGroup.put(key, graphGroup.get(key) - + "\t" + row.label); + graphGroup.put(key, graphGroup.get(key) + "\t" + row.label); } else { @@ -157,11 +198,11 @@ public class AnnotationFile { text.append(row.description + "\t"); } - - for (int j = 0; row.annotations!=null && j < row.annotations.length; j++) + for (int j = 0; row.annotations != null + && j < row.annotations.length; j++) { - if (refSeq != null && - jalview.util.Comparison.isGap(refSeq.getCharAt(j))) + if (refSeq != null + && jalview.util.Comparison.isGap(refSeq.getCharAt(j))) { continue; } @@ -169,56 +210,87 @@ public class AnnotationFile if (row.annotations[j] != null) { comma = ""; - if (row.annotations[j].secondaryStructure != ' ') + if (hasGlyphs && row.annotations[j].secondaryStructure != ' ') { + text.append(comma + row.annotations[j].secondaryStructure); comma = ","; } - if (row.annotations[j].displayCharacter!=null - && row.annotations[j].displayCharacter.length() > 0 - && !row.annotations[j].displayCharacter.equals(" ")) + if (hasValues) { - text.append(comma + row.annotations[j].displayCharacter); + if (row.annotations[j].value != Float.NaN) + { + text.append(comma + row.annotations[j].value); + } + else + { + System.err.println("Skipping NaN - not valid value."); + text.append(comma + 0f);// row.annotations[j].value); + } comma = ","; } - - if (row.annotations[j] != null) + if (hasLabels) { - if(color!=null && !color.equals(row.annotations[j].colour)) + // TODO: labels are emitted after values for bar graphs. + if // empty labels are allowed, so + (row.annotations[j].displayCharacter != null + && row.annotations[j].displayCharacter.length() > 0 + && !row.annotations[j].displayCharacter.equals(" ")) { - oneColour = false; + text.append(comma + row.annotations[j].displayCharacter); + comma = ","; } - - color = row.annotations[j].colour; - if (row.annotations[j].value != 0f && row.annotations[j].value!=Float.NaN) + } + if (hasText) + { + if (row.annotations[j].description != null + && row.annotations[j].description.length() > 0 + && !row.annotations[j].description + .equals(row.annotations[j].displayCharacter)) { - text.append(comma + row.annotations[j].value); + text.append(comma + row.annotations[j].description); + comma = ","; } } + if (color != null && !color.equals(row.annotations[j].colour)) + { + oneColour = false; + } - if(row.annotations[j].colour!=null - && row.annotations[j].colour!=java.awt.Color.black) + color = row.annotations[j].colour; + + if (row.annotations[j].colour != null + && row.annotations[j].colour != java.awt.Color.black) { - text.append(comma+"["+ - jalview.util.Format.getHexString( - row.annotations[j].colour)+"]"); + text.append(comma + + "[" + + jalview.util.Format + .getHexString(row.annotations[j].colour) + + "]"); + comma = ","; } } text.append("|"); } - if(row.hasScore()) - text.append("\t"+row.score); + if (row.hasScore()) + text.append("\t" + row.score); text.append("\n"); if (color != null && color != java.awt.Color.black && oneColour) { - colours.append("COLOUR\t" - + row.label + "\t" - + jalview.util.Format.getHexString(color) + "\n"); + colours.append("COLOUR\t" + row.label + "\t" + + jalview.util.Format.getHexString(color) + "\n"); + } + if (row.scaleColLabel || row.showAllColLabels || row.centreColLabels) + { + rowprops.append("ROWPROPERTIES\t"+row.label); + rowprops.append("\tscaletofit="+row.scaleColLabel); + rowprops.append("\tshowalllabs="+row.showAllColLabels); + rowprops.append("\tcentrelabs="+row.centreColLabels); + rowprops.append("\n"); } - } text.append("\n"); @@ -234,6 +306,7 @@ public class AnnotationFile text.append(en.nextElement() + "\n"); } } + text.append(rowprops.toString()); } if (groups != null) @@ -241,31 +314,44 @@ public class AnnotationFile printGroups(groups); } - if(properties!=null) + if (properties != null) { text.append("\n\nALIGNMENT"); Enumeration en = properties.keys(); - while(en.hasMoreElements()) + while (en.hasMoreElements()) { String key = en.nextElement().toString(); - text.append("\t"+key+"="+properties.get(key)); + text.append("\t" + key + "=" + properties.get(key)); } + // TODO: output alignment visualization settings here if required } - + return text.toString(); } public void printGroups(Vector sequenceGroups) { SequenceGroup sg; + SequenceI seqrep = null; for (int i = 0; i < sequenceGroups.size(); i++) { sg = (SequenceGroup) sequenceGroups.elementAt(i); - text.append("SEQUENCE_GROUP\t" - + sg.getName() + "\t" - + (sg.getStartRes() + 1) + "\t" - + (sg.getEndRes() + 1) + "\t" + "-1\t"); + if (!sg.hasSeqrep()) + { + text.append("SEQUENCE_GROUP\t" + sg.getName() + "\t" + + (sg.getStartRes() + 1) + "\t" + (sg.getEndRes() + 1) + + "\t" + "-1\t"); + seqrep = null; + } + else + { + seqrep = sg.getSeqrep(); + text.append("SEQUENCE_REF\t" + seqrep.getName() + "\n"); + text.append("SEQUENCE_GROUP\t" + sg.getName() + "\t" + + (seqrep.findPosition(sg.getStartRes())) + "\t" + + (seqrep.findPosition(sg.getEndRes())) + "\t" + "-1\t"); + } for (int s = 0; s < sg.getSize(); s++) { text.append(sg.getSequenceAt(s).getName() + "\t"); @@ -279,8 +365,8 @@ public class AnnotationFile } if (sg.cs != null) { - text.append("colour=" + ColourSchemeProperty.getColourName(sg.cs) + - "\t"); + text.append("colour=" + ColourSchemeProperty.getColourName(sg.cs) + + "\t"); if (sg.cs.getThreshold() != 0) { text.append("pidThreshold=" + sg.cs.getThreshold()); @@ -290,43 +376,57 @@ public class AnnotationFile text.append("consThreshold=" + sg.cs.getConservationInc() + "\t"); } } - text.append("outlineColour=" + - jalview.util.Format.getHexString(sg.getOutlineColour()) + - "\t"); + text.append("outlineColour=" + + jalview.util.Format.getHexString(sg.getOutlineColour()) + + "\t"); text.append("displayBoxes=" + sg.getDisplayBoxes() + "\t"); text.append("displayText=" + sg.getDisplayText() + "\t"); text.append("colourText=" + sg.getColourText() + "\t"); - + text.append("showUnconserved=" + sg.getShowunconserved() + "\t"); if (sg.textColour != java.awt.Color.black) { - text.append("textCol1=" + - jalview.util.Format.getHexString(sg.textColour) + "\t"); + text.append("textCol1=" + + jalview.util.Format.getHexString(sg.textColour) + "\t"); } if (sg.textColour2 != java.awt.Color.white) { - text.append("textCol2=" + - jalview.util.Format.getHexString(sg.textColour2) + "\t"); + text.append("textCol2=" + + jalview.util.Format.getHexString(sg.textColour2) + "\t"); } if (sg.thresholdTextColour != 0) { - text.append("textColThreshold=" + sg.thresholdTextColour); + text.append("textColThreshold=" + sg.thresholdTextColour + "\t"); } - if (sg.idColour!=null) + if (sg.idColour != null) { - text.append("idColour="+jalview.util.Format.getHexString(sg.idColour)+"\t"); + text.append("idColour=" + + jalview.util.Format.getHexString(sg.idColour) + "\t"); + } + if (sg.isHidereps()) + { + text.append("hide=true\t"); + } + if (sg.isHideCols()) + { + text.append("hidecols=true\t"); + } + if (seqrep != null) + { + // terminate the last line and clear the sequence ref for the group + text.append("\nSEQUENCE_REF"); } - text.append("\n\n"); } } SequenceI refSeq = null; + String refSeqId = null; - public boolean readAnnotationFile(AlignmentI al, - String file, - String protocol) + + public boolean readAnnotationFile(AlignmentI al, String file, + String protocol) { try { @@ -370,7 +470,7 @@ public class AnnotationFile // First confirm this is an Annotation file boolean jvAnnotationFile = false; - while ( (line = in.readLine()) != null) + while ((line = in.readLine()) != null) { if (line.indexOf("#") == 0) { @@ -390,11 +490,11 @@ public class AnnotationFile return false; } - while ( (line = in.readLine()) != null) + while ((line = in.readLine()) != null) { if (line.indexOf("#") == 0 - || line.indexOf("JALVIEW_ANNOTATION") > -1 - || line.length() == 0) + || line.indexOf("JALVIEW_ANNOTATION") > -1 + || line.length() == 0) { continue; } @@ -403,6 +503,7 @@ public class AnnotationFile token = st.nextToken(); if (token.equalsIgnoreCase("COLOUR")) { + // TODO: use graduated colour def'n here too colourAnnotations(al, st.nextToken(), st.nextToken()); continue; } @@ -412,7 +513,11 @@ public class AnnotationFile combineAnnotations(al, st); continue; } - + else if (token.equalsIgnoreCase("ROWPROPERTIES")) + { + addRowProperties(al, st); + continue; + } else if (token.equalsIgnoreCase("GRAPHLINE")) { addLine(al, st); @@ -423,30 +528,31 @@ public class AnnotationFile { if (st.hasMoreTokens()) { - refSeq = al.findName(refSeqId=st.nextToken()); - if (refSeq==null) - { - refSeqId=null; - } - try - { - refSeqIndex = Integer.parseInt(st.nextToken()); - if (refSeqIndex < 1) + refSeq = al.findName(refSeqId = st.nextToken()); + if (refSeq == null) + { + refSeqId = null; + } + try + { + refSeqIndex = Integer.parseInt(st.nextToken()); + if (refSeqIndex < 1) + { + refSeqIndex = 1; + System.out + .println("WARNING: SEQUENCE_REF index must be > 0 in AnnotationFile"); + } + } catch (Exception ex) { refSeqIndex = 1; - System.out.println( - "WARNING: SEQUENCE_REF index must be > 0 in AnnotationFile"); } } - catch (Exception ex) + else { - refSeqIndex = 1; - } - } else { refSeq = null; refSeqId = null; } - continue ; + continue; } else if (token.equalsIgnoreCase("SEQUENCE_GROUP")) @@ -461,12 +567,12 @@ public class AnnotationFile continue; } - else if( token.equalsIgnoreCase("BELOW_ALIGNMENT")) + else if (token.equalsIgnoreCase("BELOW_ALIGNMENT")) { setBelowAlignment(al, st); continue; } - else if( token.equalsIgnoreCase("ALIGNMENT")) + else if (token.equalsIgnoreCase("ALIGNMENT")) { addAlignmentDetails(al, st); continue; @@ -475,47 +581,46 @@ public class AnnotationFile graphStyle = AlignmentAnnotation.getGraphValueFromString(token); label = st.nextToken(); - index = 0; annotations = new Annotation[alWidth]; description = null; float score = Float.NaN; - if(st.hasMoreTokens()) + if (st.hasMoreTokens()) { line = st.nextToken(); - if (line.indexOf("|") ==-1) + if (line.indexOf("|") == -1) { description = line; if (st.hasMoreTokens()) line = st.nextToken(); } - if(st.hasMoreTokens()) + if (st.hasMoreTokens()) { - //This must be the score + // This must be the score score = Float.valueOf(st.nextToken()).floatValue(); } st = new StringTokenizer(line, "|", true); - boolean emptyColumn = true; - boolean onlyOneElement = (st.countTokens()==1); + boolean onlyOneElement = (st.countTokens() == 1); while (st.hasMoreElements() && index < alWidth) { token = st.nextToken().trim(); - if(onlyOneElement) + if (onlyOneElement) { try { score = Float.valueOf(token).floatValue(); break; + } catch (NumberFormatException ex) + { } - catch(NumberFormatException ex){} } if (token.equals("|")) @@ -529,50 +634,53 @@ public class AnnotationFile } else { - annotations[index++] = parseAnnotation(token); + annotations[index++] = parseAnnotation(token, graphStyle); emptyColumn = false; } } } - annotation = new AlignmentAnnotation(label, - description, - (index==0) ? null : annotations, - 0, - 0, - graphStyle); + annotation = new AlignmentAnnotation(label, description, + (index == 0) ? null : annotations, 0, 0, graphStyle); annotation.score = score; if (refSeq != null) { - annotation.belowAlignment=false; - do { + annotation.belowAlignment = false; + // make a copy of refSeq so we can find other matches in the alignment + SequenceI referedSeq = refSeq; + do + { // copy before we do any mapping business. - // TODO: verify that undo/redo with 1:many sequence associated annotations can be undone correctly + // TODO: verify that undo/redo with 1:many sequence associated + // annotations can be undone correctly AlignmentAnnotation ann = new AlignmentAnnotation(annotation); - annotation.createSequenceMapping(refSeq, refSeqIndex, false); + annotation + .createSequenceMapping(referedSeq, refSeqIndex, false); annotation.adjustForAlignment(); - refSeq.addAlignmentAnnotation(annotation); + referedSeq.addAlignmentAnnotation(annotation); al.addAnnotation(annotation); al.setAnnotationIndex(annotation, - al.getAlignmentAnnotation().length - existingAnnotations - - 1); + al.getAlignmentAnnotation().length + - existingAnnotations - 1); // and recover our virgin copy to use again if necessary. annotation = ann; - - } while (refSeqId!=null && (refSeq=al.findName(refSeq, refSeqId, true))!=null); - } else { + + } while (refSeqId != null + && (referedSeq = al.findName(referedSeq, refSeqId, true)) != null); + } + else + { al.addAnnotation(annotation); al.setAnnotationIndex(annotation, - al.getAlignmentAnnotation().length - existingAnnotations - - 1); + al.getAlignmentAnnotation().length - existingAnnotations + - 1); } } - } - catch (Exception ex) + } catch (Exception ex) { ex.printStackTrace(); System.out.println("Problem reading annotation file: " + ex); @@ -581,50 +689,66 @@ public class AnnotationFile return true; } - Annotation parseAnnotation(String string) + Annotation parseAnnotation(String string, int graphStyle) { + boolean hasSymbols = (graphStyle == AlignmentAnnotation.NO_GRAPH); // don't do the glyph test if we don't want secondary structure String desc = null, displayChar = null; char ss = ' '; // secondaryStructure float value = 0; - boolean parsedValue = false; + boolean parsedValue = false, dcset = false; - //find colour here + // find colour here java.awt.Color colour = null; - int i=string.indexOf("["); - int j=string.indexOf("]"); - if(i>-1 && j>-1) + int i = string.indexOf("["); + int j = string.indexOf("]"); + if (i > -1 && j > -1) { UserColourScheme ucs = new UserColourScheme(); - colour = ucs.getColourFromString(string.substring(i+1,j)); - - string = string.substring(0,i)+string.substring(j+1); + colour = ucs.getColourFromString(string.substring(i + 1, j)); + if ( i>0 && string.charAt(i-1)==',') + { + // clip the preceding comma as well + i--; + } + string = string.substring(0, i) + string.substring(j + 1); } - StringTokenizer st = new StringTokenizer(string, ","); + StringTokenizer st = new StringTokenizer(string, ",", true); String token; + boolean seenContent=false; while (st.hasMoreTokens()) { token = st.nextToken().trim(); - if (token.length() == 0) + if (token.equals(",")) { + if (!seenContent && parsedValue && !dcset) + { + // allow the value below the bar/line to be empty + dcset = true; + displayChar = " "; + } + seenContent = false; continue; + } else { + seenContent = true; } if (!parsedValue) { try { - displayChar = token; + displayChar = token; + // foo value = new Float(token).floatValue(); parsedValue = true; continue; + } catch (NumberFormatException ex) + { } - catch (NumberFormatException ex) - {} } - if (token.equals("H") || token.equals("E")) + if (hasSymbols && (token.equals("H") || token.equals("E"))) { // Either this character represents a helix or sheet // or an integer which can be displayed @@ -640,24 +764,23 @@ public class AnnotationFile } } - - if (displayChar!=null - && displayChar.length() > 1 - && desc!=null - && desc.length() == 1) +// if (!dcset && string.charAt(string.length() - 1) == ',') +// { +// displayChar = " "; // empty display char symbol. +// } + if (displayChar != null && displayChar.length() > 1 && desc != null + && desc.length() == 1) { String tmp = displayChar; displayChar = desc; desc = tmp; } /* - * In principle, this code will ensure that the Annotation element generated is renderable by any of the applet or application rendering code - * but instead we check for null strings when the display character is rendered. - if (displayChar==null) - { - displayChar=""; - } - */ + * In principle, this code will ensure that the Annotation element generated + * is renderable by any of the applet or application rendering code but + * instead we check for null strings when the display character is rendered. + * if (displayChar==null) { displayChar=""; } + */ Annotation anot = new Annotation(displayChar, desc, ss, value); anot.colour = colour; @@ -689,7 +812,7 @@ public class AnnotationFile { int graphGroup = -1; String group = st.nextToken(); - //First make sure we are not overwriting the graphIndex + // First make sure we are not overwriting the graphIndex for (int i = 0; i < al.getAlignmentAnnotation().length; i++) { if (al.getAlignmentAnnotation()[i].label.equalsIgnoreCase(group)) @@ -700,7 +823,7 @@ public class AnnotationFile } } - //Now update groups + // Now update groups while (st.hasMoreTokens()) { group = st.nextToken(); @@ -749,8 +872,36 @@ public class AnnotationFile { SequenceGroup sg = new SequenceGroup(); sg.setName(st.nextToken()); - sg.setStartRes(Integer.parseInt(st.nextToken()) - 1); - sg.setEndRes(Integer.parseInt(st.nextToken()) - 1); + String rng = ""; + try + { + rng = st.nextToken(); + if (rng.length() > 0 && !rng.startsWith("*")) + { + sg.setStartRes(Integer.parseInt(rng) - 1); + } + else + { + sg.setStartRes(0); + } + rng = st.nextToken(); + if (rng.length() > 0 && !rng.startsWith("*")) + { + sg.setEndRes(Integer.parseInt(rng) - 1); + } + else + { + sg.setEndRes(al.getWidth() - 1); + } + } catch (Exception e) + { + System.err + .println("Couldn't parse Group Start or End Field as '*' or a valid column or sequence index: '" + + rng + "' - assuming alignment width for group."); + // assume group is full width + sg.setStartRes(0); + sg.setEndRes(al.getWidth() - 1); + } String index = st.nextToken(); if (index.equals("-1")) @@ -791,17 +942,18 @@ public class AnnotationFile } else { - sg.addSequence(al.getSequenceAt(Integer.parseInt(tmp) - 1), false); + sg + .addSequence(al.getSequenceAt(Integer.parseInt(tmp) - 1), + false); } } } - - if (refSeq != null) { sg.setStartRes(refSeq.findIndex(sg.getStartRes() + 1) - 1); sg.setEndRes(refSeq.findIndex(sg.getEndRes() + 1) - 1); + sg.setSeqrep(refSeq); } if (sg.getSize() > 0) @@ -810,12 +962,41 @@ public class AnnotationFile } } + void addRowProperties(AlignmentI al, StringTokenizer st) + { + String label = st.nextToken(),keyValue,key,value; + boolean scaletofit=false,centerlab=false,showalllabs=false; + while (st.hasMoreTokens()) { + keyValue=st.nextToken(); + key = keyValue.substring(0, keyValue.indexOf("=")); + value = keyValue.substring(keyValue.indexOf("=") + 1); + if (key.equalsIgnoreCase("scaletofit")) { + scaletofit = Boolean.valueOf(value).booleanValue(); + } + if (key.equalsIgnoreCase("showalllabs")) { + showalllabs = Boolean.valueOf(value).booleanValue(); + } + if (key.equalsIgnoreCase("centrelabs")) { + centerlab = Boolean.valueOf(value).booleanValue(); + } + AlignmentAnnotation[] alr = al.getAlignmentAnnotation(); + for (int i = 0; i < alr.length; i++) + { + if (alr[i].label.equalsIgnoreCase(label)) + { + alr[i].centreColLabels = centerlab; + alr[i].scaleColLabel = scaletofit; + alr[i].showAllColLabels = showalllabs; + } + } + } + } void addProperties(AlignmentI al, StringTokenizer st) { - //So far we have only added groups to the annotationHash, - //the idea is in the future properties can be added to - //alignments, other annotations etc + // So far we have only added groups to the annotationHash, + // the idea is in the future properties can be added to + // alignments, other annotations etc if (al.getGroups() == null) { return; @@ -866,10 +1047,8 @@ public class AnnotationFile { sg.cs.setConservationInc(Integer.parseInt(value)); Conservation c = new Conservation("Group", - ResidueProperties.propHash, 3, - sg.getSequences(null), - sg.getStartRes(), - sg.getEndRes() + 1); + ResidueProperties.propHash, 3, sg.getSequences(null), sg + .getStartRes(), sg.getEndRes() + 1); c.calculate(); c.verdict(false, 25); @@ -885,6 +1064,10 @@ public class AnnotationFile { sg.setDisplayBoxes(Boolean.valueOf(value).booleanValue()); } + else if (key.equalsIgnoreCase("showUnconserved")) + { + sg.setShowunconserved(Boolean.valueOf(value).booleanValue()); + } else if (key.equalsIgnoreCase("displayText")) { sg.setDisplayText(Boolean.valueOf(value).booleanValue()); @@ -908,11 +1091,22 @@ public class AnnotationFile else if (key.equalsIgnoreCase("idColour")) { // consider warning if colour doesn't resolve to a real colour - sg.setIdColour((def = new UserColourScheme(value)).findColour('A')); + sg.setIdColour((def = new UserColourScheme(value)) + .findColour('A')); + } + else if (key.equalsIgnoreCase("hide")) + { + // see bug https://mantis.lifesci.dundee.ac.uk/view.php?id=25847 + sg.setHidereps(true); + } + else if (key.equalsIgnoreCase("hidecols")) + { + // see bug https://mantis.lifesci.dundee.ac.uk/view.php?id=25847 + sg.setHideCols(true); } sg.recalcConservation(); } - if (sg.cs==null) + if (sg.cs == null) { sg.cs = def; } @@ -923,13 +1117,13 @@ public class AnnotationFile { String token; AlignmentAnnotation aa; - while(st.hasMoreTokens()) + while (st.hasMoreTokens()) { token = st.nextToken(); - for(int i=0; ip) + if (cp > p) + { + sp.append(atos.substring(p, cp + 1)); + } + else { - sp.append(atos.substring(p, cp+1)); - } else { sp.append(atos.substring(p)); sp.append("\n"); } - p = cp+1; - } while (p>0); + p = cp + 1; + } while (p > 0); } return sp.toString(); }