X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fgui%2FAnnotationPanel.java;h=497fc2a2e26cbd1eb552be9b772faad77c6abef4;hb=ec012cb44879af718f1f9d88d669ebdc763712f2;hp=e962bdfbde8ac078f51baa1a538a51292e5ae7c0;hpb=e25f63a72efddff9e071abdeff0ae5599431e4f8;p=jalview.git

diff --git a/src/jalview/gui/AnnotationPanel.java b/src/jalview/gui/AnnotationPanel.java
index e962bdf..497fc2a 100755
--- a/src/jalview/gui/AnnotationPanel.java
+++ b/src/jalview/gui/AnnotationPanel.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
@@ -57,6 +57,11 @@ public class AnnotationPanel extends JPanel implements MouseListener,
     //Used For mouse Dragging and resizing graphs
     int graphStretch = -1;
     int graphStretchY = -1;
+    int min; //used by mouseDragged to see if user
+    int max; //used by mouseDragged to see if user
+    boolean mouseDragging = false;
+
+    boolean MAC = false;
 
     /**
      * Creates a new AnnotationPanel object.
@@ -65,6 +70,10 @@ public class AnnotationPanel extends JPanel implements MouseListener,
      */
     public AnnotationPanel(AlignmentPanel ap)
     {
+
+    if(System.getProperty("os.name").startsWith("Mac"))
+      MAC = true;
+
         ToolTipManager.sharedInstance().registerComponent(this);
         ToolTipManager.sharedInstance().setInitialDelay(0);
         ToolTipManager.sharedInstance().setDismissDelay(10000);
@@ -269,13 +278,17 @@ public class AnnotationPanel extends JPanel implements MouseListener,
      */
     public void mousePressed(MouseEvent evt)
     {
-        int height = 0;
-        activeRow = -1;
+
 
         AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();
         if(aa==null)
           return;
 
+
+        int height = 0;
+        activeRow = -1;
+
+
         for (int i = 0; i < aa.length; i++)
         {
             if (aa[i].visible)
@@ -300,6 +313,7 @@ public class AnnotationPanel extends JPanel implements MouseListener,
             }
         }
 
+
         if (SwingUtilities.isRightMouseButton(evt))
         {
             if (av.getColumnSelection() == null)
@@ -335,34 +349,28 @@ public class AnnotationPanel extends JPanel implements MouseListener,
 
         int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
 
-        if (evt.isShiftDown())
-        {
-                /*int start = Integer.parseInt(activeRes.get(activeRes.size() -
-                            1).toString());
-                int end = res;
+        min = res;
+        max = res;
 
-                if (end < start)
-                {
-                    int temp = end;
-                    end = start;
-                    start = temp;
-                }
-
-                for (int n = start; n <= end; n++)
-                {
-                   addEditableColumn(n);
-                } */
-        }
+        if (av.getColumnSelection().contains(res))
+          av.getColumnSelection().removeElement(res);
         else
         {
-          if (av.getColumnSelection().contains(res))
-            av.getColumnSelection().removeElement(res);
-          else
             av.getColumnSelection().addElement(res);
+            SequenceGroup sg = new SequenceGroup();
 
-          ap.repaint();
+            for (int i = 0; i < av.alignment.getSequences().size(); i++)
+            {
+                sg.addSequence(av.alignment.getSequenceAt(i), false);
+            }
 
+            sg.setStartRes(res);
+            sg.setEndRes(res);
+            av.setSelectionGroup(sg);
         }
+
+        ap.repaint();
+
     }
 
     /**
@@ -374,6 +382,7 @@ public class AnnotationPanel extends JPanel implements MouseListener,
     {
       graphStretch = -1;
       graphStretchY = -1;
+      mouseDragging = false;
     }
 
     /**
@@ -383,6 +392,8 @@ public class AnnotationPanel extends JPanel implements MouseListener,
      */
     public void mouseEntered(MouseEvent evt)
     {
+      if(mouseDragging)
+        ap.seqPanel.scrollCanvas(null);
     }
 
     /**
@@ -392,8 +403,11 @@ public class AnnotationPanel extends JPanel implements MouseListener,
      */
     public void mouseExited(MouseEvent evt)
     {
+      if(mouseDragging)
+        ap.seqPanel.scrollCanvas(evt);
     }
 
+
     /**
      * DOCUMENT ME!
      *
@@ -404,12 +418,62 @@ public class AnnotationPanel extends JPanel implements MouseListener,
       if(graphStretch>-1)
       {
         av.alignment.getAlignmentAnnotation()[graphStretch].graphHeight += graphStretchY - evt.getY();
-        if(av.alignment.getAlignmentAnnotation()[graphStretch].graphHeight <10)
-          av.alignment.getAlignmentAnnotation()[graphStretch].graphHeight = 10;
+        if(av.alignment.getAlignmentAnnotation()[graphStretch].graphHeight <0)
+          av.alignment.getAlignmentAnnotation()[graphStretch].graphHeight = 0;
         graphStretchY = evt.getY();
         adjustPanelHeight();
         ap.repaint();
       }
+      else
+      {
+        mouseDragging = true;
+
+        int res = (evt.getX() / av.getCharWidth()) + av.getStartRes();
+
+        SequenceGroup sg = av.getSelectionGroup();
+
+        if (res < min)
+        {
+            min = res;
+        }
+
+        if (res > max)
+        {
+            max = res;
+        }
+
+        if (sg != null)
+        {
+            if (!av.getColumnSelection().contains(res))
+            {
+                av.getColumnSelection().addElement(res);
+            }
+
+            if (res > sg.getStartRes())
+            {
+                sg.setEndRes(res);
+            }
+            else if (res < sg.getStartRes())
+            {
+                sg.setStartRes(res);
+            }
+
+            for (int i = min; i <= max; i++)
+            {
+                if ((i < sg.getStartRes()) || (i > sg.getEndRes()))
+                {
+                    av.getColumnSelection().removeElement(i);
+                }
+                else
+                {
+                    av.getColumnSelection().addElement(i);
+                }
+            }
+
+            ap.repaint();
+        }
+
+      }
     }
 
     /**
@@ -591,23 +655,24 @@ public class AnnotationPanel extends JPanel implements MouseListener,
         g.setColor(Color.white);
         g.fillRect(0, 0, (endRes - startRes) * av.charWidth, getHeight());
 
-        if ((av.alignment.getAlignmentAnnotation() == null) ||
+        if ( (av.alignment.getAlignmentAnnotation() == null) ||
                 (av.alignment.getAlignmentAnnotation().length < 1))
         {
             g.setColor(Color.white);
             g.fillRect(0, 0, getWidth(), getHeight());
             g.setColor(Color.black);
-            g.drawString("Alignment has no annotations", 20, 15);
+            if(av.validCharWidth)
+              g.drawString("Alignment has no annotations", 20, 15);
 
             return;
         }
 
         AlignmentAnnotation[] aa = av.alignment.getAlignmentAnnotation();
 
-        int x = 0;
-        int y = 0;
-        char[] lastSS = new char[aa.length];
-        int[] lastSSX = new int[aa.length];
+        int x = 0, y = 0;
+        int column=0;
+        char lastSS;
+        int lastSSX;
         int iconOffset = av.charHeight / 2;
         boolean validRes = false;
 
@@ -624,7 +689,8 @@ public class AnnotationPanel extends JPanel implements MouseListener,
                 continue;
             }
 
-
+            lastSS = ' ';
+            lastSSX = 0;
 
             if (row.graph>0)
             {
@@ -642,29 +708,27 @@ public class AnnotationPanel extends JPanel implements MouseListener,
 
             if (row.hasText)
             {
-                iconOffset = av.charHeight / 2;
+                iconOffset = av.charHeight / 2 + 4;
             }
             else
             {
                 iconOffset = 0;
             }
 
-            int column = startRes;
-            int yPos = startRes;
-            int aaMax = row.annotations.length-1;
-
-            while (yPos < endRes)
+            x = 0;
+            while (x < endRes-startRes)
             {
               if (av.hasHiddenColumns)
               {
-                column = av.getColumnSelection().adjustForHiddenColumns(yPos);
-                if (column > aaMax)
+                column = av.getColumnSelection().adjustForHiddenColumns(startRes+x);
+                if (column > row.annotations.length-1)
                 {
                   break;
                 }
               }
               else
-                column = yPos;
+                column = startRes+x;
+
 
                 if ((row.annotations.length <= column) ||
                         (row.annotations[column] == null))
@@ -676,7 +740,6 @@ public class AnnotationPanel extends JPanel implements MouseListener,
                     validRes = true;
                 }
 
-                x = (yPos - startRes) * av.charWidth;
 
                 if (activeRow == i)
                 {
@@ -690,14 +753,14 @@ public class AnnotationPanel extends JPanel implements MouseListener,
 
                             if (v == column)
                             {
-                                g.fillRect((column - startRes) * av.charWidth, y,
-                                    av.charWidth, row.height);
+                                g.fillRect(x * av.charWidth, y,
+                                    av.charWidth, av.charHeight);
                             }
                         }
                     }
                 }
 
-                if (validRes &&
+                if (av.validCharWidth && validRes &&
                         (row.annotations[column].displayCharacter.length() > 0))
                 {
 
@@ -708,37 +771,72 @@ public class AnnotationPanel extends JPanel implements MouseListener,
 
                     if (column == 0 || row.graph>0)
                     {
-                        g.drawString(row.annotations[column].displayCharacter, x+charOffset,
-                            y + iconOffset + 3);
+                        g.drawString(row.annotations[column].displayCharacter,
+                                     (x*av.charWidth)+charOffset,
+                            y + iconOffset );
                     }
-                    else if (((row.annotations[column - 1] == null) ||
-                            (row.annotations[column].displayCharacter != row.annotations[column -
-                            1].displayCharacter)))
+                    else if (
+                        row.annotations[column - 1] == null
+                        ||(!row.annotations[column].displayCharacter.equals(
+                            row.annotations[column - 1].displayCharacter)
+                        ||
+                  (row.annotations[column].displayCharacter.length() <2 &&
+                   row.annotations[column].secondaryStructure==' ')))
                     {
-                        g.drawString(row.annotations[column].displayCharacter, x+charOffset,
-                            y + iconOffset + 3);
+                        g.drawString(row.annotations[column].displayCharacter,
+                                     x*av.charWidth+charOffset,
+                                     y + iconOffset );
                     }
                 }
 
                 if (row.hasIcons)
                 {
                     if (!validRes ||
-                            (row.annotations[column].secondaryStructure != lastSS[i]))
+                            (row.annotations[column].secondaryStructure != lastSS))
                     {
-                        switch (lastSS[i])
+                        switch (lastSS)
                         {
                         case 'H':
-                            g.setColor(HELIX_COLOUR);
-                            g.fillRoundRect(lastSSX[i], y + 4 + iconOffset,
-                                x - lastSSX[i], 7, 8, 8);
-
+                          g.setColor(HELIX_COLOUR);
+                          if (MAC)
+                          {
+                            //Off by 1 offset when drawing rects and ovals
+                            //to offscreen image on the MAC
+                            g.fillRoundRect(lastSSX, y + 4 + iconOffset,
+                                            (x*av.charWidth) - lastSSX, 7, 8, 8);
                             break;
+                          }
+
+                          int sCol = (lastSSX / av.charWidth) + startRes;
+                          int x1 = lastSSX;
+                          int x2 = (x*av.charWidth);
+
+                         if(sCol==0 ||
+                            row.annotations[sCol-1]==null ||
+                            row.annotations[sCol-1].secondaryStructure!='H')
+                         {
+                           g.fillArc(lastSSX, y+4+iconOffset, av.charWidth, 8, 90,180) ;
+                           x1 += av.charWidth/2;
+                         }
+
+                          if(row.annotations[column]==null ||
+                             row.annotations[column].secondaryStructure!='H')
+                          {
+                            g.fillArc((x*av.charWidth)-av.charWidth,
+                                      y+4+iconOffset, av.charWidth, 8, 270,180);
+                            x2 -= av.charWidth/2;
+                          }
+
+                          g.fillRect(x1, y+4+iconOffset, x2-x1, 8);
+                              break;
 
                         case 'E':
                             g.setColor(SHEET_COLOUR);
-                            g.fillRect(lastSSX[i], y + 4 + iconOffset,
-                                x - lastSSX[i] - 4, 7);
-                            g.fillPolygon(new int[] { x - 4, x - 4, x },
+                            g.fillRect(lastSSX, y + 4 + iconOffset,
+                                (x*av.charWidth) - lastSSX - 4, 7);
+                            g.fillPolygon(new int[] { (x*av.charWidth) - 4,
+                                          (x*av.charWidth) - 4,
+                                          (x*av.charWidth) },
                                 new int[]
                                 {
                                     y + iconOffset, y + 14 + iconOffset,
@@ -750,75 +848,111 @@ public class AnnotationPanel extends JPanel implements MouseListener,
 
                         default:
                             g.setColor(Color.gray);
-                            g.fillRect(lastSSX[i], y + 6 + iconOffset,
-                                x - lastSSX[i], 2);
+                            g.fillRect(lastSSX, y + 6 + iconOffset,
+                                (x*av.charWidth) - lastSSX, 2);
 
                             break;
                         }
 
                         if (validRes)
                         {
-                            lastSS[i] = row.annotations[column].secondaryStructure;
+                            lastSS = row.annotations[column].secondaryStructure;
                         }
                         else
                         {
-                            lastSS[i] = ' ';
+                            lastSS = ' ';
                         }
 
-                        lastSSX[i] = x;
+                        lastSSX = (x*av.charWidth);
                     }
                 }
 
-                yPos++;
+
+            column++;
+            x++;
             }
 
-            x += av.charWidth;
+            if(column>=row.annotations.length)
+                column = row.annotations.length-1;
+
+          //  x ++;
 
             if (row.hasIcons)
             {
-                switch (lastSS[i])
-                {
+              switch (lastSS)
+              {
                 case 'H':
-                    g.setColor(HELIX_COLOUR);
-                    g.fillRoundRect(lastSSX[i], y + 4 + iconOffset,
-                        x - lastSSX[i], 7, 8, 8);
-
+                  g.setColor(HELIX_COLOUR);
+                  if (MAC)
+                  {
+                    //Off by 1 offset when drawing rects and ovals
+                    //to offscreen image on the MAC
+                    g.fillRoundRect(lastSSX, y + 4 + iconOffset,
+                                    (x*av.charWidth) - lastSSX, 7, 8, 8);
                     break;
+                  }
+
+                  int sCol = (lastSSX / av.charWidth) + startRes;
+                  int x1 = lastSSX;
+                  int x2 = (x*av.charWidth);
+
+                  if (sCol == 0 ||
+                      row.annotations[sCol - 1] == null ||
+                      row.annotations[sCol - 1].secondaryStructure != 'H')
+                  {
+                    g.fillArc(lastSSX, y + 4 + iconOffset, av.charWidth, 8, 90, 180);
+                    x1 += av.charWidth / 2;
+                  }
+
+                  if (row.annotations[column] == null ||
+                      row.annotations[column].secondaryStructure != 'H')
+                  {
+                    g.fillArc((x*av.charWidth) - av.charWidth,
+                              y + 4 + iconOffset, av.charWidth, 8, 270,
+                              180);
+                    x2 -= av.charWidth / 2;
+                  }
+
+                  g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);
 
-                case 'E':
-                    g.setColor(SHEET_COLOUR);
-
-                    if (row.annotations[endRes] !=null
-                        && row.annotations[endRes].secondaryStructure != 'E')
-                    {
-                      g.fillRect(lastSSX[i], y + 4 + iconOffset,
-                                 x - lastSSX[i] - 4, 7);
-                      g.fillPolygon(new int[]
-                                    {x - 4, x - 4, x},
-                                    new int[]
-                                    {
-                                    y + iconOffset, y + 14 + iconOffset,
-                                    y + 7 + iconOffset
-                      }, 3);
-                    }
-                    else
-                      g.fillRect(lastSSX[i], y + 4 + iconOffset,
-                                 x - lastSSX[i], 7);
-
-                    break;
+                  break;
 
-                case 'C':
-                    break;
+                case 'E':
+                  g.setColor(SHEET_COLOUR);
+
+                  if (row.annotations[endRes] == null
+                      || row.annotations[endRes].secondaryStructure != 'E')
+                  {
+                    g.fillRect(lastSSX, y + 4 + iconOffset,
+                               (x*av.charWidth) - lastSSX - 4, 7);
+                    g.fillPolygon(new int[]
+                                  {(x*av.charWidth) - 4,
+                                  (x*av.charWidth) - 4,
+                                 (x*av.charWidth)},
+                                  new int[]
+                                  {
+                                  y + iconOffset, y + 14 + iconOffset,
+                                  y + 7 + iconOffset
+                    }, 3);
+                  }
+                  else
+                   {
+                     g.fillRect(lastSSX, y + 4 + iconOffset,
+                                (x+1) * av.charWidth - lastSSX, 7);
+                   }
+                  break;
 
                 default:
-                    g.setColor(Color.gray);
-                    g.fillRect(lastSSX[i], y + 6 + iconOffset, x - lastSSX[i], 2);
+                  g.setColor(Color.gray);
+                  if(!av.wrapAlignment || endRes==av.endRes)
+                  g.fillRect(lastSSX, y + 6 + iconOffset,
+                             (x*av.charWidth) - lastSSX, 2);
 
-                    break;
-                }
-            }
+                  break;
+              }
+          }
 
-            if (row.graph>0)
+            if (row.graph>0 && row.graphHeight>0)
             {
                 if(row.graph == AlignmentAnnotation.LINE_GRAPH )
                 {
@@ -881,7 +1015,6 @@ public class AnnotationPanel extends JPanel implements MouseListener,
       if(sRes>aa.annotations.length)
         return;
 
-      eRes = Math.min(eRes, aa.annotations.length);
 
       int x = 0;
 
@@ -889,10 +1022,11 @@ public class AnnotationPanel extends JPanel implements MouseListener,
       if(eRes<av.endRes)
         eRes++;
 
+      eRes = Math.min(eRes, aa.annotations.length);
+
       if(sRes==0)
       {
-        sRes++;
-        x+=av.charWidth;
+        x++;
       }
 
       int y1=y, y2=y;
@@ -900,59 +1034,57 @@ public class AnnotationPanel extends JPanel implements MouseListener,
 
       ////Draw origin
       if(min<0)
-        y2 = (int)(y - (0-min / range)*graphHeight);
+        y2 = y - (int)((0-min / range)*graphHeight);
 
       g.setColor(Color.gray);
       g.drawLine(x-av.charWidth,y2,(eRes-sRes+1)*av.charWidth,y2);
 
-
-      if(aa.threshold!=null)
-      {
-          g.setColor(aa.threshold.colour);
-          Graphics2D g2 = (Graphics2D)g;
-          g2.setStroke(new BasicStroke(1,
-                                        BasicStroke.CAP_SQUARE,
-                                        BasicStroke.JOIN_ROUND, 3f,
-                                        new float[] { 5f, 3f }, 0f));
-
-          y2 = (int)(y - ((aa.threshold.value-min) / range)*graphHeight);
-          g.drawLine(x-av.charWidth,y2,(eRes-sRes)*av.charWidth,y2);
-          g2.setStroke(new BasicStroke());
-      }
-
       eRes = Math.min(eRes, aa.annotations.length);
 
-      int column = sRes;
-      int yPos = sRes;
+      int column;
       int aaMax = aa.annotations.length-1;
 
-      while( yPos < eRes )
+      while( x < eRes - sRes )
       {
+        column = sRes + x;
         if(av.hasHiddenColumns)
         {
-          column = av.getColumnSelection().adjustForHiddenColumns(yPos);
-          if(column > aaMax)
-          {
-            break;
-          }
+          column = av.getColumnSelection().adjustForHiddenColumns(column);
         }
-        else
-          column = yPos;
 
-        yPos ++;
+        if (column > aaMax)
+        {
+          break;
+        }
 
         if(aa.annotations[column]==null || aa.annotations[column-1]==null)
         {
-          x+=av.charWidth;
+          x++;
           continue;
         }
 
+
           g.setColor(aa.annotations[column].colour);
           y1 = y - (int) (((aa.annotations[column-1].value-min) / range) * graphHeight);
           y2 = y - (int) (((aa.annotations[column].value-min) / range) * graphHeight);
-          g.drawLine(x-av.charWidth/2, y1, x+av.charWidth/2, y2);
-          x += av.charWidth;
+
+          g.drawLine(x*av.charWidth-av.charWidth/2, y1, x*av.charWidth+av.charWidth/2, y2);
+          x ++;
        }
+
+       if(aa.threshold!=null)
+       {
+           g.setColor(aa.threshold.colour);
+           Graphics2D g2 = (Graphics2D)g;
+           g2.setStroke(new BasicStroke(1,
+                                         BasicStroke.CAP_SQUARE,
+                                         BasicStroke.JOIN_ROUND, 3f,
+                                         new float[] { 5f, 3f }, 0f));
+
+           y2 = (int)(y - ((aa.threshold.value-min) / range)*graphHeight);
+           g.drawLine(0,y2,(eRes-sRes)*av.charWidth,y2);
+           g2.setStroke(new BasicStroke());
+      }
     }
 
     public void drawBarGraph(Graphics g, AlignmentAnnotation aa,
@@ -965,76 +1097,69 @@ public class AnnotationPanel extends JPanel implements MouseListener,
 
       eRes = Math.min(eRes, aa.annotations.length);
 
-      int x=0, y1, y2;
+      int x=0, y1=y, y2=y;
 
       float range = max - min;
 
-      if(aa.threshold!=null)
-      {
-          g.setColor(aa.threshold.colour);
-          Graphics2D g2 = (Graphics2D)g;
-          g2.setStroke(new BasicStroke(1,
-                                        BasicStroke.CAP_SQUARE,
-                                        BasicStroke.JOIN_ROUND, 3f,
-                                        new float[] { 5f, 3f }, 0f));
-
-          y2 = (int)(y - ((aa.threshold.value-min) / range)*aa.graphHeight);
-          g.drawLine(x-av.charWidth,y2,(eRes-sRes)*av.charWidth,y2);
-          g2.setStroke(new BasicStroke());
-      }
-
-      y1 = y2 = y;
-
       if(min<0)
-        y2 = (int)(y - (0-min / (range))*aa.graphHeight);
+        y2 = y - (int)((0-min / (range))*aa.graphHeight);
 
       g.setColor(Color.gray);
 
       g.drawLine(x,y2,(eRes-sRes)*av.charWidth,y2);
 
-
-      int column = sRes;
-      int yPos = sRes;
+      int column;
       int aaMax = aa.annotations.length-1;
 
-      while( yPos < eRes )
+      while( x < eRes-sRes )
       {
+        column = sRes + x;
         if(av.hasHiddenColumns)
         {
-          column = av.getColumnSelection().adjustForHiddenColumns(yPos);
-          if(column > aaMax)
-          {
-            break;
-          }
+          column = av.getColumnSelection().adjustForHiddenColumns(column);
         }
-        else
-          column = yPos;
 
-        yPos ++;
+        if(column > aaMax)
+        {
+            break;
+        }
 
         if (aa.annotations[column] == null)
         {
-          x += av.charWidth;
+          x ++;
           continue;
         }
 
-
           g.setColor(aa.annotations[column].colour);
           y1 = y - (int) (((aa.annotations[column].value-min) / (range)) * aa.graphHeight);
 
           if(y1-y2>0)
-            g.fillRect(x, y2, av.charWidth, y1-y2 );
+            g.fillRect(x*av.charWidth, y2, av.charWidth, y1-y2 );
           else
-            g.fillRect(x, y1, av.charWidth, y2-y1 );
+            g.fillRect(x*av.charWidth, y1, av.charWidth, y2-y1 );
+
+          x ++ ;
 
-          x += av.charWidth;
       }
+      if(aa.threshold!=null)
+      {
+          g.setColor(aa.threshold.colour);
+          Graphics2D g2 = (Graphics2D)g;
+          g2.setStroke(new BasicStroke(1,
+                                        BasicStroke.CAP_SQUARE,
+                                        BasicStroke.JOIN_ROUND, 3f,
+                                        new float[] { 5f, 3f }, 0f));
 
+          y2 = (int)(y - ((aa.threshold.value-min) / range)*aa.graphHeight);
+          g.drawLine(0,y2,(eRes-sRes)*av.charWidth,y2);
+          g2.setStroke(new BasicStroke());
+      }
     }
 
     // used by overview window
     public void drawGraph(Graphics g, AlignmentAnnotation aa, int width, int y, int sRes, int eRes)
     {
+      eRes = Math.min(eRes, aa.annotations.length);
       g.setColor(Color.white);
       g.fillRect(0, 0, width, y);
       g.setColor(new Color(0, 0, 180));