X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fappletgui%2FAlignViewport.java;h=87753f4de3bbaf9545745da284c6a7c0d58ad79f;hb=f4fd7b0e74572c8fddbfe9e3e55bc624f8ba0c6a;hp=209f9394768709490deaa61ff0246d009e50acb6;hpb=ee53965807b83bf93a21cbc341cee9a9e005b2cb;p=jalview.git

diff --git a/src/jalview/appletgui/AlignViewport.java b/src/jalview/appletgui/AlignViewport.java
index 209f939..87753f4 100755
--- a/src/jalview/appletgui/AlignViewport.java
+++ b/src/jalview/appletgui/AlignViewport.java
@@ -1,6 +1,6 @@
 /*
  * Jalview - A Sequence Alignment Editor and Viewer
- * Copyright (C) 2005 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle
+ * Copyright (C) 2006 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
@@ -36,7 +36,10 @@ public class AlignViewport
   int startSeq;
   int endSeq;
 
-  boolean showFullId = true;
+
+  boolean cursorMode = false;
+
+  boolean showJVSuffix = true;
   boolean showText = true;
   boolean showColourText = false;
   boolean showBoxes = true;
@@ -53,13 +56,14 @@ public class AlignViewport
   boolean conservationColourSelected = false;
   boolean abovePIDThreshold = false;
 
-  SequenceGroup selectionGroup = new SequenceGroup();
+  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();
@@ -73,19 +77,35 @@ public class AlignViewport
   boolean scaleLeftWrapped = true;
   boolean scaleRightWrapped = true;
 
+  // The following vector holds the features which are
+ // currently visible, in the correct order or rendering
+  Hashtable featuresDisplayed;
+
+  boolean hasHiddenColumns = false;
+  boolean hasHiddenRows = false;
+  boolean showHiddenMarkers = true;
+
+
   public Vector vconsensus;
   AlignmentAnnotation consensus;
   AlignmentAnnotation conservation;
   AlignmentAnnotation quality;
 
+  boolean autocalculateConsensus = true;
+
   public int ConsPercGaps = 25; // JBPNote : This should be a scalable property!
 
   private java.beans.PropertyChangeSupport changeSupport = new java.beans.PropertyChangeSupport(this);
 
   boolean ignoreGapsInConsensusCalculation = false;
 
+  jalview.bin.JalviewLite applet;
+
+  boolean MAC = false;
+
   public AlignViewport(AlignmentI al, JalviewLite applet)
   {
+    this.applet = applet;
     setAlignment(al);
     this.startRes = 0;
     this.endRes = al.getWidth() - 1;
@@ -93,12 +113,15 @@ public class AlignViewport
     this.endSeq = al.getHeight() - 1;
     setFont(font);
 
+    if(System.getProperty("os.name").startsWith("Mac"))
+      MAC = true;
+
     if (applet != null)
     {
       String param = applet.getParameter("showFullId");
       if (param != null)
       {
-        showFullId = Boolean.valueOf(param).booleanValue();
+        showJVSuffix = Boolean.valueOf(param).booleanValue();
       }
 
       param = applet.getParameter("showAnnotation");
@@ -130,14 +153,34 @@ public class AlignViewport
     updateConservation();
     updateConsensus();
 
-    if (applet != null && applet.getParameter("defaultColour") != null)
+
+    if (applet != null)
     {
-      globalColourScheme = ColourSchemeProperty.getColour(alignment,
-          applet.getParameter("defaultColour"));
-      if (globalColourScheme != null)
+      String colour = applet.getParameter("defaultColour");
+
+      if(colour == null)
+      {
+        colour = applet.getParameter("userDefinedColour");
+        if(colour !=null)
+          colour = "User Defined";
+      }
+
+      if(colour != null)
+      {
+        globalColourScheme = ColourSchemeProperty.getColour(alignment, colour);
+        if (globalColourScheme != null)
+        {
+          globalColourScheme.setConsensus(vconsensus);
+        }
+      }
+
+      if(applet.getParameter("userDefinedColour")!=null)
       {
-        globalColourScheme.setConsensus(vconsensus);
+        ((UserColourScheme)globalColourScheme).parseAppletParameter(
+            applet.getParameter("userDefinedColour"));
       }
+
+
     }
   }
 
@@ -146,6 +189,11 @@ public class AlignViewport
     showSequenceFeatures = b;
   }
 
+  public boolean getShowSequenceFeatures()
+  {
+    return showSequenceFeatures;
+  }
+
 
   public void updateConservation()
   {
@@ -221,7 +269,7 @@ public class AlignViewport
                                              annotations,
                                              0f, // cons.qualityRange[0].floatValue(),
                                              11f, // cons.qualityRange[1].floatValue()
-                                             1);
+                                             AlignmentAnnotation.BAR_GRAPH);
       if (showConservation)
       {
         alignment.addAnnotation(conservation);
@@ -231,7 +279,7 @@ public class AlignViewport
                                         qannotations,
                                         cons.qualityRange[0].floatValue(),
                                         cons.qualityRange[1].floatValue(),
-                                        1);
+                                        AlignmentAnnotation.BAR_GRAPH);
       if (showQuality)
       {
         alignment.addAnnotation(quality);
@@ -294,7 +342,7 @@ public class AlignViewport
     if (consensus == null)
     {
       consensus = new AlignmentAnnotation("Consensus",
-                                          "PID", annotations, 0f, 100f, 1);
+                                          "PID", annotations, 0f, 100f, AlignmentAnnotation.BAR_GRAPH);
       if (showConsensus)
       {
         alignment.addAnnotation(consensus);
@@ -309,7 +357,32 @@ public class AlignViewport
           globalColourScheme.setConsensus(vconsensus);
 
   }
-
+  /**
+   * 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.
+   * @return consensus sequence as a new sequence object
+   */
+  public SequenceI getConsensusSeq() {
+    if (consensus==null)
+      updateConsensus();
+    if (consensus==null)
+      return null;
+    StringBuffer seqs=new StringBuffer();
+    for (int i=0; i<consensus.annotations.length; i++) {
+      if (consensus.annotations[i]!=null) {
+        if (consensus.annotations[i].description.charAt(0) == '[')
+          seqs.append(consensus.annotations[i].description.charAt(1));
+        else
+          seqs.append(consensus.annotations[i].displayCharacter);
+      }
+    }
+    SequenceI sq = new Sequence("Consensus", seqs.toString());
+    sq.setDescription("Percentage Identity Consensus "+((ignoreGapsInConsensusCalculation) ? " without gaps" : ""));
+    return sq;
+  }
   public SequenceGroup getSelectionGroup()
   {
     return selectionGroup;
@@ -407,14 +480,19 @@ public class AlignViewport
     return endSeq;
   }
 
+  java.awt.Frame nullFrame;
   public void setFont(Font f)
   {
     font = f;
-    java.awt.Frame temp = new java.awt.Frame();
-    temp.addNotify();
-    java.awt.FontMetrics fm = temp.getGraphics().getFontMetrics(font);
+    if(nullFrame == null)
+    {
+      nullFrame = new java.awt.Frame();
+      nullFrame.addNotify();
+    }
+
+    java.awt.FontMetrics fm = nullFrame.getGraphics().getFontMetrics(font);
     setCharHeight(fm.getHeight());
-    setCharWidth(fm.charWidth('M'));
+    charWidth = fm.charWidth('M');
   }
 
   public Font getFont()
@@ -422,11 +500,6 @@ public class AlignViewport
     return font;
   }
 
-  public void setCharWidth(int w)
-  {
-    this.charWidth = w;
-  }
-
   public int getCharWidth()
   {
     return charWidth;
@@ -540,30 +613,11 @@ public class AlignViewport
     return increment;
   }
 
-  public int getIndex(int y)
+  public void setHiddenColumns(ColumnSelection colsel)
   {
-    int y1 = 0;
-    int starty = getStartSeq();
-    int endy = getEndSeq();
-
-    for (int i = starty; i <= endy; i++)
-    {
-      if (i < alignment.getHeight() && alignment.getSequenceAt(i) != null)
-      {
-        int y2 = y1 + getCharHeight();
-
-        if (y >= y1 && y <= y2)
-        {
-          return i;
-        }
-        y1 = y2;
-      }
-      else
-      {
-        return -1;
-      }
-    }
-    return -1;
+    this.colSel = colsel;
+    if(colSel.getHiddenColumns()!=null)
+      hasHiddenColumns = true;
   }
 
   public ColumnSelection getColumnSelection()
@@ -596,14 +650,14 @@ public class AlignViewport
     return colourAppliesToAllGroups;
   }
 
-  public boolean getShowFullId()
+  public boolean getShowJVSuffix()
   {
-    return showFullId;
+    return showJVSuffix;
   }
 
-  public void setShowFullId(boolean b)
+  public void setShowJVSuffix(boolean b)
   {
-    showFullId = b;
+    showJVSuffix = b;
   }
 
   public boolean getShowAnnotation()
@@ -698,6 +752,307 @@ public class AlignViewport
   {
     return ignoreGapsInConsensusCalculation;
   }
+  public void hideSelectedColumns()
+  {
+    if (colSel.size() < 1)
+      return;
+
+    colSel.hideSelectedColumns();
+    setSelectionGroup(null);
+
+    hasHiddenColumns = true;
+  }
+
+  public void invertColumnSelection()
+  {
+    int column;
+    for (int i = 0; i < alignment.getWidth(); i++)
+    {
+      column = i;
+
+      if (colSel.contains(column))
+        colSel.removeElement(column);
+      else
+        colSel.addElement(column);
+
+    }
+  }
+
+
+  public void hideColumns(int start, int end)
+  {
+    if(start==end)
+      colSel.hideColumns(start);
+    else
+      colSel.hideColumns(start, end);
+
+    hasHiddenColumns = true;
+  }
+
+  public void hideAllSelectedSeqs()
+  {
+    if (selectionGroup == null)
+      return;
+
+    SequenceI[] seqs = selectionGroup.getSequencesInOrder(alignment);
+
+    hideSequence(seqs);
+
+    setSelectionGroup(null);
+  }
+
+  public void hideSequence(SequenceI [] seq)
+  {
+    if(seq!=null)
+    {
+      for (int i = 0; i < seq.length; i++)
+        alignment.getHiddenSequences().hideSequence(seq[i]);
+
+      hasHiddenRows = true;
+      firePropertyChange("alignment", null, alignment.getSequences());
+    }
+  }
+
+  public void showColumn(int col)
+  {
+    colSel.revealHiddenColumns(col);
+    if(colSel.getHiddenColumns()==null)
+      hasHiddenColumns = false;
+  }
+
+  public void showAllHiddenColumns()
+  {
+    colSel.revealAllHiddenColumns();
+    hasHiddenColumns = false;
+  }
+
+  public void showAllHiddenSeqs()
+  {
+    if(alignment.getHiddenSequences().getSize()>0)
+    {
+      if(selectionGroup==null)
+      {
+        selectionGroup = new SequenceGroup();
+        selectionGroup.setEndRes(alignment.getWidth()-1);
+      }
+      Vector tmp = alignment.getHiddenSequences().showAll();
+      for(int t=0; t<tmp.size(); t++)
+      {
+        selectionGroup.addSequence(
+            (SequenceI)tmp.elementAt(t), false
+            );
+      }
+      firePropertyChange("alignment", null, alignment.getSequences());
+      hasHiddenRows = false;
+    }
+  }
+
+  public int adjustForHiddenSeqs(int alignmentIndex)
+  {
+    return alignment.getHiddenSequences().adjustForHiddenSeqs(alignmentIndex);
+  }
+
+  /**
+   * This method returns the a new SequenceI [] with
+   * the selection sequence and start and end points adjusted
+   * @return String[]
+   */
+  public SequenceI[] getSelectionAsNewSequence()
+  {
+    SequenceI[] sequences;
+
+    if (selectionGroup == null)
+      sequences = alignment.getSequencesArray();
+    else
+      sequences = selectionGroup.getSelectionAsNewSequences(alignment);
+
+    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)
+  {
+    CigarArray selection=null;
+    SequenceI [] seqs= null;
+    int i, iSize;
+    int start = 0, end = 0;
+    if(selectedRegionOnly && selectionGroup!=null)
+    {
+      iSize = selectionGroup.getSize(false);
+      seqs = selectionGroup.getSequencesInOrder(alignment);
+      start = selectionGroup.getStartRes();
+      end = selectionGroup.getEndRes(); // inclusive for start and end in SeqCigar constructor
+    }
+    else
+    {
+      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);
+    }
+    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;
+
+        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;
+  }
+  /**
+   * 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
+    // 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);
+    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.
+   * @return String[]
+   */
+  public String [] getViewAsString(boolean selectedRegionOnly)
+  {
+    String [] selection = null;
+    SequenceI [] seqs= null;
+    int i, iSize;
+    int start = 0, end = 0;
+    if(selectedRegionOnly && selectionGroup!=null)
+    {
+      iSize = selectionGroup.getSize(false);
+      seqs = selectionGroup.getSequencesInOrder(alignment);
+      start = selectionGroup.getStartRes();
+      end = selectionGroup.getEndRes()+1;
+    }
+    else
+    {
+      iSize = alignment.getHeight();
+      seqs = alignment.getSequencesArray();
+      end = alignment.getWidth();
+    }
+
+    selection = new String[iSize];
+
+
+    for(i=0; i<iSize; i++)
+    {
+      if (hasHiddenColumns)
+      {
+           StringBuffer visibleSeq = new StringBuffer();
+           Vector regions = colSel.getHiddenColumns();
+
+           int blockStart = start, blockEnd=end;
+           int [] region;
+           int hideStart, hideEnd;
+
+           for (int j = 0; j < regions.size(); j++)
+           {
+             region = (int[]) regions.elementAt(j);
+             hideStart = region[0];
+             hideEnd = region[1];
+
+             if(hideStart < start)
+             {
+               continue;
+             }
+
+             blockStart = Math.min(blockStart, hideEnd+1);
+             blockEnd = Math.min(blockEnd, hideStart);
+
+             if(blockStart>blockEnd)
+             {
+                break;
+             }
+
+
+             visibleSeq.append(seqs[i].getSequence(blockStart, blockEnd));
+
+             blockStart = hideEnd+1;
+             blockEnd = end;
+           }
+
+           if(end>blockStart)
+             visibleSeq.append(seqs[i].getSequence(blockStart, end));
+
+           selection[i] = visibleSeq.toString();
+      }
+      else
+      {
+        selection[i] = seqs[i].getSequence(start, end);
+      }
+    }
+
+    return selection;
+  }
+
+  public boolean getShowHiddenMarkers()
+  {
+    return showHiddenMarkers;
+  }
+
+  public void setShowHiddenMarkers(boolean show)
+  {
+    showHiddenMarkers = show;
+  }
 
 
 }