X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Frenderer%2FAnnotationRenderer.java;h=d943d3932fb4de3f980151e09b09bc4b0c0f82ae;hb=refs%2Fheads%2Ffeature%2FJAL-4274_configurable_bitmap_export_preferences;hp=5aea2cf38932db2af3d8304257b3615b818e1799;hpb=7f14a135f0c03e8a01185ebfbddab5cbe11b4e4a;p=jalview.git

diff --git a/src/jalview/renderer/AnnotationRenderer.java b/src/jalview/renderer/AnnotationRenderer.java
index 5aea2cf..d943d39 100644
--- a/src/jalview/renderer/AnnotationRenderer.java
+++ b/src/jalview/renderer/AnnotationRenderer.java
@@ -28,11 +28,15 @@ import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.Image;
 import java.awt.RenderingHints;
+import java.awt.Stroke;
 import java.awt.geom.AffineTransform;
 import java.awt.image.ImageObserver;
 import java.util.BitSet;
 import java.util.Hashtable;
 
+import org.jfree.graphics2d.svg.SVGGraphics2D;
+import org.jibble.epsgraphics.EpsGraphics2D;
+
 import jalview.analysis.AAFrequency;
 import jalview.analysis.CodingUtils;
 import jalview.analysis.Rna;
@@ -91,6 +95,10 @@ public class AnnotationRenderer
 
   private boolean av_ignoreGapsConsensus;
 
+  private boolean vectorRendition = false;
+
+  private boolean glyphLineDrawn = false;
+
   /**
    * attributes set from AwtRenderPanelI
    */
@@ -234,7 +242,6 @@ public class AnnotationRenderer
   {
     // Console.info(nonCanColor);
 
-    g.setColor(nonCanColor);
     int sCol = (lastSSX / charWidth)
             + hiddenColumns.visibleToAbsoluteColumn(startRes);
     int x1 = lastSSX;
@@ -252,6 +259,12 @@ public class AnnotationRenderer
     // "+diffupstream+"
     // down:"+diffdownstream);
     // If a closing base pair half of the stem, display a backward arrow
+    if (diffupstream || diffdownstream)
+    {
+      // draw glyphline under arrow
+      drawGlyphLine(g, lastSSX, x, y, iconOffset);
+    }
+    g.setColor(nonCanColor);
     if (column > 0 && Rna.isClosingParenthesis(dc))
     {
 
@@ -261,7 +274,8 @@ public class AnnotationRenderer
       {
         fillPolygon(g, new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
                 new int[]
-                { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
+                { y + iconOffset + 1, y + 13 + iconOffset,
+                    y + 7 + iconOffset },
                 3);
         x1 += 5;
       }
@@ -276,9 +290,10 @@ public class AnnotationRenderer
       // display a forward arrow
       if (diffdownstream)
       {
-        fillPolygon(g, new int[] { x2 - 5, x2 - 5, x2 },
+        fillPolygon(g, new int[] { x2 - 6, x2 - 6, x2 - 1 },
                 new int[]
-                { y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
+                { y + iconOffset + 1, y + 13 + iconOffset,
+                    y + 7 + iconOffset },
                 3);
         x2 -= 5;
       }
@@ -288,7 +303,8 @@ public class AnnotationRenderer
       }
     }
     // draw arrow body
-    fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 7);
+    unsetAntialias(g);
+    fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 6);
   }
 
   // public void updateFromAnnotationPanel(FontMetrics annotFM, AlignViewportI
@@ -451,14 +467,11 @@ public class AnnotationRenderer
           AlignViewportI av, Graphics g, int activeRow, int startRes,
           int endRes)
   {
-    Graphics2D g2d = (Graphics2D) g;
-    if (Cache.getDefault("ANTI_ALIAS", true))
+    if (g instanceof EpsGraphics2D || g instanceof SVGGraphics2D)
     {
-      g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-              RenderingHints.VALUE_ANTIALIAS_ON);
-      g2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
-              RenderingHints.VALUE_STROKE_PURE);
+      this.setVectorRendition(true);
     }
+    Graphics2D g2d = (Graphics2D) g;
 
     long stime = System.currentTimeMillis();
     boolean usedFaded = false;
@@ -605,9 +618,13 @@ public class AnnotationRenderer
          * 
          * continue; }
          */
+
         // first pass sets up state for drawing continuation from left-hand
         // column
         // of startRes
+
+        // flag used for vector rendition
+        this.glyphLineDrawn = false;
         x = (startRes == 0) ? 0 : -1;
         while (x < endRes - startRes)
         {
@@ -639,6 +656,7 @@ public class AnnotationRenderer
                   : null;
           if (x > -1)
           {
+            unsetAntialias(g);
             if (activeRow == i)
             {
               g.setColor(Color.red);
@@ -714,6 +732,7 @@ public class AnnotationRenderer
                 g2d.transform(
                         AffineTransform.getScaleInstance(fmScaling, 1.0));
               }
+              setAntialias(g);
               if (column == 0 || row.graph > 0)
               {
                 g2d.drawString(displayChar, 0, 0);
@@ -892,10 +911,17 @@ public class AnnotationRenderer
                   // temp = x;
                   break;
                 default:
-                  g.setColor(GLYPHLINE_COLOR);
-                  g.fillRect(lastSSX, y + 6 + iconOffset,
-                          (x * charWidth) - lastSSX, 2);
-                  // temp = x;
+                  if (isVectorRendition())
+                  {
+                    // draw single full width glyphline
+                    drawGlyphLine(g, lastSSX, endRes - x, y, iconOffset);
+                    // disable more glyph lines
+                    this.glyphLineDrawn = true;
+                  }
+                  else
+                  {
+                    drawGlyphLine(g, lastSSX, x, y, iconOffset);
+                  }
                   break;
                 }
               }
@@ -1026,8 +1052,17 @@ public class AnnotationRenderer
                     x, y, iconOffset, startRes, column, validRes, validEnd);
             break;
           default:
-            drawGlyphLine(g, row_annotations, lastSSX, x, y, iconOffset,
-                    startRes, column, validRes, validEnd);
+            if (isVectorRendition())
+            {
+              // draw single full width glyphline
+              drawGlyphLine(g, lastSSX, endRes - x, y, iconOffset);
+              // disable more glyph lines
+              this.glyphLineDrawn = true;
+            }
+            else
+            {
+              drawGlyphLine(g, lastSSX, x, y, iconOffset);
+            }
             break;
           }
         }
@@ -1154,7 +1189,7 @@ public class AnnotationRenderer
 
   public static final Color GLYPHLINE_COLOR = Color.gray;
 
-  public static final Color SHEET_COLOUR = Color.green.darker();
+  public static final Color SHEET_COLOUR = Color.green;
 
   public static final Color HELIX_COLOUR = Color.red;
 
@@ -1162,12 +1197,16 @@ public class AnnotationRenderer
 
   // private Color sdNOTCANONICAL_COLOUR;
 
-  void drawGlyphLine(Graphics g, Annotation[] row, int lastSSX, int x,
-          int y, int iconOffset, int startRes, int column, boolean validRes,
-          boolean validEnd)
+  void drawGlyphLine(Graphics g, int lastSSX, int x, int y, int iconOffset)
   {
+    if (glyphLineDrawn)
+    {
+      // if we've drawn a single long glyphline for an export, don't draw the
+      // bits
+      return;
+    }
+    unsetAntialias(g);
     g.setColor(GLYPHLINE_COLOR);
-    unsetAntiAlias(g);
     g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - lastSSX, 2);
   }
 
@@ -1176,47 +1215,52 @@ public class AnnotationRenderer
           int lastSSX, int x, int y, int iconOffset, int startRes,
           int column, boolean validRes, boolean validEnd)
   {
-    g.setColor(SHEET_COLOUR);
-
     if (!validEnd || !validRes || row == null || row[column] == null
             || row[column].secondaryStructure != 'E')
     {
+      // draw the glyphline underneath
+      drawGlyphLine(g, lastSSX, x, y, iconOffset);
+
+      g.setColor(SHEET_COLOUR);
       fillRect(g, lastSSX, y + 4 + iconOffset,
               (x * charWidth) - lastSSX - 4, 6);
       fillPolygon(g,
               new int[]
-              { (x * charWidth) - 4, (x * charWidth) - 4, (x * charWidth) },
+              { (x * charWidth) - 6, (x * charWidth) - 6,
+                  (x * charWidth - 1) },
               new int[]
-              { y + iconOffset, y + 14 + iconOffset, y + 7 + iconOffset },
+              { y + iconOffset + 1, y + 13 + iconOffset,
+                  y + 7 + iconOffset },
               3);
     }
     else
     {
-      fillRect(g, lastSSX, y + 4 + iconOffset,
-              (x + 1) * charWidth - lastSSX, 6);
+      g.setColor(SHEET_COLOUR);
+      fillRect(g, lastSSX, y + 4 + iconOffset, (x * charWidth) - lastSSX,
+              6);
     }
-
   }
 
   void drawHelixAnnot(Graphics g, Annotation[] row, int lastSSX, int x,
           int y, int iconOffset, int startRes, int column, boolean validRes,
           boolean validEnd)
   {
-    g.setColor(HELIX_COLOUR);
-
     int sCol = (lastSSX / charWidth)
             + hiddenColumns.visibleToAbsoluteColumn(startRes);
     int x1 = lastSSX;
     int x2 = (x * charWidth);
 
-    y--;
-
-    if (USE_FILL_ROUND_RECT)
+    if (USE_FILL_ROUND_RECT || isVectorRendition())
     {
+      // draw glyph line behind helix (visible in EPS or SVG output)
+      drawGlyphLine(g, lastSSX, x, y, iconOffset);
+
+      g.setColor(HELIX_COLOUR);
+      setAntialias(g);
       int ofs = charWidth / 2;
       // Off by 1 offset when drawing rects and ovals
       // to offscreen image on the MAC
-      fillRoundRect(g, lastSSX, y + 4 + iconOffset, x2 - x1, 8, 8, 8);
+      fillRoundRect(g, lastSSX, y + 3 + iconOffset, x2 - x1 - 1, 8, 8, 8);
       if (sCol == 0 || row[sCol - 1] == null
               || row[sCol - 1].secondaryStructure != 'H')
       {
@@ -1224,8 +1268,8 @@ public class AnnotationRenderer
       else
       {
         // g.setColor(Color.orange);
-        fillRoundRect(g, lastSSX, y + 4 + iconOffset, x2 - x1 - ofs + 1, 8,
-                0, 0);
+        fillRoundRect(g, lastSSX, y + 3 + iconOffset, x2 - x1 - ofs, 8, 0,
+                0);
       }
       if (!validRes || row[column] == null
               || row[column].secondaryStructure != 'H')
@@ -1235,30 +1279,38 @@ public class AnnotationRenderer
       else
       {
         // g.setColor(Color.magenta);
-        fillRoundRect(g, lastSSX + ofs, y + 4 + iconOffset,
-                x2 - x1 - ofs + 1, 8, 0, 0);
-
+        fillRoundRect(g, lastSSX + ofs, y + 3 + iconOffset, x2 - x1 - ofs,
+                8, 0, 0);
       }
 
       return;
     }
 
-    if (sCol == 0 || row[sCol - 1] == null
-            || row[sCol - 1].secondaryStructure != 'H')
+    boolean leftEnd = sCol == 0 || row[sCol - 1] == null
+            || row[sCol - 1].secondaryStructure != 'H';
+    boolean rightEnd = !validRes || row[column] == null
+            || row[column].secondaryStructure != 'H';
+
+    if (leftEnd || rightEnd)
+    {
+      drawGlyphLine(g, lastSSX, x, y, iconOffset);
+    }
+    g.setColor(HELIX_COLOUR);
+
+    if (leftEnd)
     {
-      fillArc(g, lastSSX, y + 4 + iconOffset, charWidth, 8, 90, 180);
+      fillArc(g, lastSSX, y + 3 + iconOffset, charWidth, 8, 90, 180);
       x1 += charWidth / 2;
     }
 
-    if (!validRes || row[column] == null
-            || row[column].secondaryStructure != 'H')
+    if (rightEnd)
     {
-      fillArc(g, (x * charWidth) - charWidth, y + 4 + iconOffset, charWidth,
-              8, 270, 180);
+      fillArc(g, ((x - 1) * charWidth), y + 3 + iconOffset, charWidth, 8,
+              270, 180);
       x2 -= charWidth / 2;
     }
 
-    fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 8);
+    fillRect(g, x1, y + 3 + iconOffset, x2 - x1, 8);
   }
 
   void drawLineGraph(Graphics g, AlignmentAnnotation _aa,
@@ -1269,6 +1321,13 @@ public class AnnotationRenderer
     {
       return;
     }
+    Stroke roundStroke = new BasicStroke(1, BasicStroke.CAP_ROUND,
+            BasicStroke.JOIN_ROUND);
+    Stroke squareStroke = new BasicStroke(1, BasicStroke.CAP_SQUARE,
+            BasicStroke.JOIN_MITER);
+    Graphics2D g2d = (Graphics2D) g;
+    Stroke prevStroke = g2d.getStroke();
+    g2d.setStroke(roundStroke);
 
     int x = 0;
 
@@ -1295,7 +1354,8 @@ public class AnnotationRenderer
     }
 
     g.setColor(Color.gray);
-    g.drawLine(x - charWidth, y2, (eRes - sRes + 1) * charWidth, y2);
+    drawLine(g, squareStroke, x * charWidth - charWidth, y2,
+            (eRes - sRes) * charWidth, y2);
 
     eRes = Math.min(eRes, aa_annotations.length);
 
@@ -1337,7 +1397,7 @@ public class AnnotationRenderer
         // standalone value
         y1 = y - (int) (((aa_annotations[column].value - min) / range)
                 * graphHeight);
-        g.drawLine(x * charWidth + charWidth / 4, y1,
+        drawLine(g, x * charWidth + charWidth / 4, y1,
                 x * charWidth + 3 * charWidth / 4, y1);
         x++;
         continue;
@@ -1354,7 +1414,7 @@ public class AnnotationRenderer
       y2 = y - (int) (((aa_annotations[column].value - min) / range)
               * graphHeight);
 
-      g.drawLine(x * charWidth - charWidth / 2, y1,
+      drawLine(g, (x - 1) * charWidth + charWidth / 2, y1,
               x * charWidth + charWidth / 2, y2);
       x++;
     }
@@ -1363,14 +1423,14 @@ public class AnnotationRenderer
     {
       g.setColor(_aa.threshold.colour);
       Graphics2D g2 = (Graphics2D) g;
-      g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
+      Stroke s = new BasicStroke(1, BasicStroke.CAP_SQUARE,
               BasicStroke.JOIN_ROUND, 3f, new float[]
-              { 5f, 3f }, 0f));
+              { 5f, 3f }, 0f);
 
       y2 = (int) (y - ((_aa.threshold.value - min) / range) * graphHeight);
-      g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
-      g2.setStroke(new BasicStroke());
+      drawLine(g, s, 0, y2, (eRes - sRes) * charWidth, y2);
     }
+    g2d.setStroke(prevStroke);
   }
 
   @SuppressWarnings("unused")
@@ -1397,7 +1457,7 @@ public class AnnotationRenderer
 
     g.setColor(Color.gray);
 
-    g.drawLine(x, y2, (eRes - sRes) * charWidth, y2);
+    drawLine(g, x, y2, (eRes - sRes) * charWidth, y2);
 
     int column;
     int aaMax = aa_annotations.length - 1;
@@ -1596,15 +1656,13 @@ public class AnnotationRenderer
     if (_aa.threshold != null)
     {
       g.setColor(_aa.threshold.colour);
-      Graphics2D g2 = (Graphics2D) g;
-      g2.setStroke(new BasicStroke(1, BasicStroke.CAP_SQUARE,
+      Stroke s = new BasicStroke(1, BasicStroke.CAP_SQUARE,
               BasicStroke.JOIN_ROUND, 3f, new float[]
-              { 5f, 3f }, 0f));
+              { 5f, 3f }, 0f);
 
       y2 = (int) (y
               - ((_aa.threshold.value - min) / range) * _aa.graphHeight);
-      g.drawLine(0, y2, (eRes - sRes) * charWidth, y2);
-      g2.setStroke(new BasicStroke());
+      drawLine(g, s, 0, y2, (eRes - sRes) * charWidth, y2);
     }
   }
 
@@ -1771,39 +1829,59 @@ public class AnnotationRenderer
     }
   }
 
-  private static void fillPolygon(Graphics g, int[] xpoints, int[] ypoints,
-          int n)
+  private void fillPolygon(Graphics g, int[] xpoints, int[] ypoints, int n)
   {
-    setAntiAlias(g);
+    setAntialias(g);
     g.fillPolygon(xpoints, ypoints, n);
-    g.drawPolygon(xpoints, ypoints, n);
   }
 
-  private static void fillRect(Graphics g, int a, int b, int c, int d)
+  /*
+  private void fillRect(Graphics g, int a, int b, int c, int d)
   {
-    setAntiAlias(g);
+    fillRect(g, false, a, b, c, d);
+  }*/
+
+  private void fillRect(Graphics g, int a, int b, int c, int d)
+  {
+    unsetAntialias(g);
     g.fillRect(a, b, c, d);
-    g.drawRect(a, b, c, d);
   }
 
-  private static void fillRoundRect(Graphics g, int a, int b, int c, int d,
-          int e, int f)
+  private void fillRoundRect(Graphics g, int a, int b, int c, int d, int e,
+          int f)
   {
-    setAntiAlias(g);
+    setAntialias(g);
     g.fillRoundRect(a, b, c, d, e, f);
-    g.drawRoundRect(a, b, c, d, e, f);
   }
 
-  private static void fillArc(Graphics g, int a, int b, int c, int d, int e,
-          int f)
+  private void fillArc(Graphics g, int a, int b, int c, int d, int e, int f)
   {
-    setAntiAlias(g);
+    setAntialias(g);
     g.fillArc(a, b, c, d, e, f);
-    g.drawArc(a, b, c, d, e, f);
   }
 
-  private static void setAntiAlias(Graphics g)
+  private void drawLine(Graphics g, Stroke s, int a, int b, int c, int d)
+  {
+    Graphics2D g2d = (Graphics2D) g;
+    Stroke p = g2d.getStroke();
+    g2d.setStroke(s);
+    drawLine(g, a, b, c, d);
+    g2d.setStroke(p);
+  }
+
+  private void drawLine(Graphics g, int a, int b, int c, int d)
   {
+    setAntialias(g);
+    g.drawLine(a, b, c, d);
+  }
+
+  private void setAntialias(Graphics g)
+  {
+    if (isVectorRendition())
+    {
+      // no need to antialias vector drawings
+      return;
+    }
     if (Cache.getDefault("ANTI_ALIAS", true))
     {
       Graphics2D g2d = (Graphics2D) g;
@@ -1812,10 +1890,25 @@ public class AnnotationRenderer
     }
   }
 
-  private static void unsetAntiAlias(Graphics g)
+  private void unsetAntialias(Graphics g)
   {
+    if (isVectorRendition())
+    {
+      // no need to antialias vector drawings
+      return;
+    }
     Graphics2D g2d = (Graphics2D) g;
     g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
             RenderingHints.VALUE_ANTIALIAS_OFF);
   }
+
+  public void setVectorRendition(boolean b)
+  {
+    vectorRendition = b;
+  }
+
+  public boolean isVectorRendition()
+  {
+    return vectorRendition;
+  }
 }