*/
package jalview.viewmodel;
+import java.awt.Color;
+import java.beans.PropertyChangeSupport;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
import jalview.analysis.AnnotationSorter.SequenceAnnotationOrder;
import jalview.analysis.Conservation;
import jalview.analysis.TreeModel;
import jalview.api.AlignCalcManagerI;
+import jalview.api.AlignExportSettingsI;
import jalview.api.AlignViewportI;
import jalview.api.AlignmentViewPanel;
import jalview.api.FeaturesDisplayedI;
import jalview.api.ViewStyleI;
+import jalview.bin.Console;
import jalview.commands.CommandI;
import jalview.datamodel.AlignedCodonFrame;
import jalview.datamodel.AlignmentAnnotation;
+import jalview.datamodel.AlignmentExportData;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.AlignmentView;
import jalview.datamodel.Annotation;
import jalview.datamodel.ColumnSelection;
+import jalview.datamodel.ContactListI;
+import jalview.datamodel.ContactMatrixI;
import jalview.datamodel.HiddenColumns;
import jalview.datamodel.HiddenSequences;
import jalview.datamodel.ProfilesI;
import jalview.datamodel.SequenceCollectionI;
import jalview.datamodel.SequenceGroup;
import jalview.datamodel.SequenceI;
+import jalview.gui.QuitHandler;
+import jalview.project.Jalview2XML;
import jalview.renderer.ResidueShader;
import jalview.renderer.ResidueShaderI;
import jalview.schemes.ColourSchemeI;
import jalview.workers.AlignCalcManager;
import jalview.workers.ComplementConsensusThread;
import jalview.workers.ConsensusThread;
+import jalview.workers.SecondaryStructureConsensusThread;
import jalview.workers.StrucConsensusThread;
-import java.awt.Color;
-import java.beans.PropertyChangeSupport;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.BitSet;
-import java.util.Deque;
-import java.util.HashMap;
-import java.util.Hashtable;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
/**
* base class holding visualization and analysis attributes and common logic for
* an active alignment view displayed in the GUI
protected Deque<CommandI> redoList = new ArrayDeque<>();
/**
+ * used to determine if quit should be confirmed
+ */
+ private boolean savedUpToDate = false;
+
+ /**
* alignment displayed in the viewport. Please use get/setter
*/
protected AlignmentI alignment;
* retain any colour thresholds per group while
* changing choice of colour scheme (JAL-2386)
*/
- sg.setColourScheme(
- cs == null ? null : cs.getInstance(this, sg));
+ sg.setColourScheme(cs == null ? null : cs.getInstance(this, sg));
if (cs != null)
{
sg.getGroupColourScheme().alignmentChanged(sg,
}
protected AlignmentAnnotation consensus;
+
+ protected AlignmentAnnotation secondaryStructureConsensus;
protected AlignmentAnnotation complementConsensus;
protected AlignmentAnnotation quality;
protected AlignmentAnnotation[] groupConsensus;
+
+ protected AlignmentAnnotation[] groupSSConsensus;
protected AlignmentAnnotation[] groupConservation;
* results of alignment consensus analysis for visible portion of view
*/
protected ProfilesI hconsensus = null;
+
+ protected ProfilesI hSSConsensus = null;
+
+
/**
* results of cDNA complement consensus visible portion of view
*/
- protected Hashtable[] hcomplementConsensus = null;
+ protected Hashtable<String, Object>[] hcomplementConsensus = null;
/**
* results of secondary structure base pair consensus for visible portion of
* view
*/
- protected Hashtable[] hStrucConsensus = null;
+ protected Hashtable<String, Object>[] hStrucConsensus = null;
protected Conservation hconservation = null;
{
this.hconsensus = hconsensus;
}
-
+
@Override
- public void setComplementConsensusHash(Hashtable[] hconsensus)
+ public void setSequenceSSConsensusHash(ProfilesI hSSConsensus)
+ {
+ this.hSSConsensus = hSSConsensus;
+ }
+
+ @Override
+ public void setComplementConsensusHash(
+ Hashtable<String, Object>[] hconsensus)
{
this.hcomplementConsensus = hconsensus;
}
{
return hconsensus;
}
+
+ @Override
+ public ProfilesI getSequenceSSConsensusHash()
+ {
+ return hSSConsensus;
+ }
@Override
- public Hashtable[] getComplementConsensusHash()
+ public Hashtable<String, Object>[] getComplementConsensusHash()
{
return hcomplementConsensus;
}
@Override
- public Hashtable[] getRnaStructureConsensusHash()
+ public Hashtable<String, Object>[] getRnaStructureConsensusHash()
{
return hStrucConsensus;
}
@Override
- public void setRnaStructureConsensusHash(Hashtable[] hStrucConsensus)
+ public void setRnaStructureConsensusHash(
+ Hashtable<String, Object>[] hStrucConsensus)
{
this.hStrucConsensus = hStrucConsensus;
return consensus;
}
+
+ @Override
+ public AlignmentAnnotation getAlignmentSecondaryStructureConsensusAnnotation()
+ {
+ return secondaryStructureConsensus;
+ }
+
+
@Override
public AlignmentAnnotation getAlignmentGapAnnotation()
{
}
}
}
+
+
+
+
+ /**
+ * trigger update of consensus annotation
+ */
+ public void updateSecondaryStructureConsensus(final AlignmentViewPanel ap)
+ {
+ // see note in mantis : issue number 8585
+ if (secondaryStructureConsensus == null || !autoCalculateConsensus)
+ {
+ return;
+ }
+ if (calculator
+ .getRegisteredWorkersOfClass(SecondaryStructureConsensusThread.class) == null)
+ {
+ calculator.registerWorker(new SecondaryStructureConsensusThread(this, ap));
+ }
+ }
// --------START Structure Conservation
public void updateStrucConsensus(final AlignmentViewPanel ap)
}
if (calculator.workingInvolvedWith(alignmentAnnotation))
{
- // System.err.println("grey out ("+alignmentAnnotation.label+")");
+ // jalview.bin.Console.errPrintln("grey out
+ // ("+alignmentAnnotation.label+")");
return true;
}
return false;
consensus = null;
complementConsensus = null;
strucConsensus = null;
+ secondaryStructureConsensus = null;
conservation = null;
quality = null;
groupConsensus = null;
* should consensus profile be rendered by default
*/
protected boolean showSequenceLogo = false;
+
+ protected boolean showSequenceSSLogo = false;
/**
* should consensus profile be rendered normalised to row height
* should consensus histograms be rendered by default
*/
protected boolean showConsensusHistogram = true;
+
+ protected boolean showSSConsensusHistogram = true;
+
+ public void setShowSSConsensusHistogram(boolean showSSConsensusHistogram)
+ {
+ this.showSSConsensusHistogram = showSSConsensusHistogram;
+ }
/**
* @return the showConsensusProfile
{
return showSequenceLogo;
}
+
+ @Override
+ public boolean isShowSequenceSSLogo()
+ {
+ return showSequenceSSLogo;
+ }
/**
* @param showSequenceLogo
}
this.showSequenceLogo = showSequenceLogo;
}
+
+ public void setShowSequenceSSLogo(boolean showSequenceSSLogo)
+ {
+ if (showSequenceSSLogo != this.showSequenceSSLogo)
+ {
+ // TODO: decouple settings setting from calculation when refactoring
+ // annotation update method from alignframe to viewport
+ this.showSequenceSSLogo = showSequenceSSLogo;
+ calculator.updateAnnotationFor(SecondaryStructureConsensusThread.class);
+ }
+ this.showSequenceSSLogo = showSequenceSSLogo;
+ }
/**
* @param showConsensusHistogram
{
return this.showConsensusHistogram;
}
+
+ @Override
+ public boolean isShowSSConsensusHistogram()
+ {
+ return this.showSSConsensusHistogram;
+ }
/**
* when set, updateAlignment will always ensure sequences are of equal length
{
if (sequenceSetID != null)
{
- System.err.println(
+ jalview.bin.Console.errPrintln(
"Warning - overwriting a sequenceSetId for a viewport!");
}
sequenceSetID = new String(newid);
if (ap != null)
{
updateConsensus(ap);
+ updateSecondaryStructureConsensus(ap);
if (residueShading != null)
{
residueShading.setThreshold(residueShading.getThreshold(),
}
} while (end < max);
- int[][] startEnd = new int[regions.size()][2];
+ // int[][] startEnd = new int[regions.size()][2];
return regions;
}
AlignmentAnnotation clone = new AlignmentAnnotation(annot);
if (selectedOnly && selectionGroup != null)
{
- clone.makeVisibleAnnotation(
- selectionGroup.getStartRes(), selectionGroup.getEndRes(),
- alignment.getHiddenColumns());
+ clone.makeVisibleAnnotation(selectionGroup.getStartRes(),
+ selectionGroup.getEndRes(), alignment.getHiddenColumns());
}
else
{
if (autoCalculateConsensus)
{
updateConsensus(ap);
+ updateSecondaryStructureConsensus(ap);
}
if (hconsensus != null && autoCalculateConsensus)
{
consensus = new AlignmentAnnotation("Consensus",
MessageManager.getString("label.consensus_descr"),
new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
+
+ secondaryStructureConsensus = new AlignmentAnnotation("SecondaryStructureConsensus",
+ MessageManager.getString("label.ssconsensus_descr"),
+ new Annotation[1], 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
+
initConsensus(consensus);
+ initSSConsensus(secondaryStructureConsensus);
initGapCounts();
-
initComplementConsensus();
}
}
+
/**
* If this is a protein alignment and there are mappings to cDNA, adds the
* cDNA consensus annotation and returns true, else returns false.
alignment.addAnnotation(aa);
}
}
+
+ private void initSSConsensus(AlignmentAnnotation aa)
+ {
+ aa.hasText = true;
+ aa.autoCalculated = true;
+
+ if (showConsensus)
+ {
+ alignment.addAnnotation(aa);
+ }
+ }
// these should be extracted from the view model - style and settings for
// derived annotation
{
if (aa == null)
{
- System.err.println("Null annotation row: ignoring.");
+ jalview.bin.Console.errPrintln("Null annotation row: ignoring.");
continue;
}
if (!aa.visible)
if (aa.graph > 0)
{
- aa.height += aa.graphHeight;
+ aa.height += aa.graphHeight + 20;
}
if (aa.height == 0)
boolean conv = isShowGroupConservation();
boolean cons = isShowGroupConsensus();
boolean showprf = isShowSequenceLogo();
+ boolean showSSprf = isShowSequenceSSLogo();
boolean showConsHist = isShowConsensusHistogram();
+ boolean showSSConsHist = isShowSSConsensusHistogram();
boolean normLogo = isNormaliseSequenceLogo();
/**
* TODO reorder the annotation rows according to group/sequence ordering on
* alignment
*/
- boolean sortg = true;
+ // boolean sortg = true;
// remove old automatic annotation
// add any new annotation
{
// set defaults for this group's conservation/consensus
sg.setshowSequenceLogo(showprf);
+ sg.setshowSequenceSSLogo(showSSprf);
sg.setShowConsensusHistogram(showConsHist);
+ sg.setShowSSConsensusHistogram(showSSConsHist);
sg.setNormaliseSequenceLogo(normLogo);
}
if (conv)
{
updateCalcs = true;
alignment.addAnnotation(sg.getConsensus(), 0);
+ alignment.addAnnotation(sg.getSSConsensus(), 0);
}
// refresh the annotation rows
if (updateCalcs)
public void clearSequenceColours()
{
sequenceColours.clear();
- };
+ }
@Override
public AlignViewportI getCodingComplement()
{
if (this == av)
{
- System.err.println("Ignoring recursive setCodingComplement request");
+ jalview.bin.Console
+ .errPrintln("Ignoring recursive setCodingComplement request");
}
else
{
{
this.historyList.push(command);
broadcastCommand(command, false);
+ setSavedUpToDate(false);
+ Jalview2XML.setStateSavedUpToDate(false);
}
}
return searchResults;
}
+ @Override
+ public ContactListI getContactList(AlignmentAnnotation _aa, int column)
+ {
+ return alignment.getContactListFor(_aa, column);
+ }
+
+ @Override
+ public ContactMatrixI getContactMatrix(
+ AlignmentAnnotation alignmentAnnotation)
+ {
+ return alignment.getContactMatrixFor(alignmentAnnotation);
+ }
+
/**
* get the consensus sequence as displayed under the PID consensus annotation
* row.
+ ((ignoreGapsInConsensusCalculation) ? " without gaps" : ""));
return sq;
}
+
+ public SequenceI getSSConsensusSeq()
+ {
+ if (secondaryStructureConsensus == null)
+ {
+ updateSecondaryStructureConsensus(null);
+ }
+ if (secondaryStructureConsensus == null)
+ {
+ return null;
+ }
+ StringBuffer seqs = new StringBuffer();
+ for (int i = 0; i < secondaryStructureConsensus.annotations.length; i++)
+ {
+ Annotation annotation = secondaryStructureConsensus.annotations[i];
+ if (annotation != null)
+ {
+ String description = annotation.description;
+ if (description != null && description.startsWith("["))
+ {
+ // consensus is a tie - just pick the first one
+ seqs.append(description.charAt(1));
+ }
+ else
+ {
+ seqs.append(annotation.displayCharacter);
+ }
+ }
+ }
+
+ SequenceI sq = new Sequence("Sec Str Consensus", seqs.toString());
+ sq.setDescription("Percentage Identity Sec Str Consensus "
+ + ((ignoreGapsInConsensusCalculation) ? " without gaps" : ""));
+ return sq;
+ }
@Override
public void setCurrentTree(TreeModel tree)
return currentTree;
}
+ @Override
+ public AlignmentExportData getAlignExportData(
+ AlignExportSettingsI options)
+ {
+ AlignmentI alignmentToExport = null;
+ String[] omitHidden = null;
+ alignmentToExport = null;
+
+ if (hasHiddenColumns() && !options.isExportHiddenColumns())
+ {
+ omitHidden = getViewAsString(false,
+ options.isExportHiddenSequences());
+ }
+
+ int[] alignmentStartEnd = new int[2];
+ if (hasHiddenRows() && options.isExportHiddenSequences())
+ {
+ alignmentToExport = getAlignment().getHiddenSequences()
+ .getFullAlignment();
+ }
+ else
+ {
+ alignmentToExport = getAlignment();
+ }
+ alignmentStartEnd = getAlignment().getHiddenColumns()
+ .getVisibleStartAndEndIndex(alignmentToExport.getWidth());
+ AlignmentExportData ed = new AlignmentExportData(alignmentToExport,
+ omitHidden, alignmentStartEnd);
+ return ed;
+ }
+
/**
* flag set to indicate if structure views might be out of sync with sequences
* in the alignment
codingComplement.setUpdateStructures(needToUpdateStructureViews);
}
}
+
+ @Override
+ public Iterator<int[]> getViewAsVisibleContigs(boolean selectedRegionOnly)
+ {
+ int start = 0;
+ int end = 0;
+ if (selectedRegionOnly && selectionGroup != null)
+ {
+ start = selectionGroup.getStartRes();
+ end = selectionGroup.getEndRes() + 1;
+ }
+ else
+ {
+ end = alignment.getWidth();
+ }
+ return (alignment.getHiddenColumns().getVisContigsIterator(start, end,
+ false));
+ }
+
+ public void setSavedUpToDate(boolean s)
+ {
+ setSavedUpToDate(s, QuitHandler.Message.UNSAVED_CHANGES);
+ }
+
+ public void setSavedUpToDate(boolean s, QuitHandler.Message m)
+ {
+ Console.debug(
+ "Setting " + this.getViewId() + " setSavedUpToDate to " + s);
+ savedUpToDate = s;
+ QuitHandler.setMessage(m);
+ }
+
+ public boolean savedUpToDate()
+ {
+ Console.debug("Returning " + this.getViewId() + " savedUpToDate value: "
+ + savedUpToDate);
+ return savedUpToDate;
+ }
}