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;
private boolean av_ignoreGapsConsensus;
+ private boolean vectorRendition = false;
+
+ private boolean glyphLineDrawn = false;
+
/**
* attributes set from AwtRenderPanelI
*/
int x, int y, int iconOffset, int startRes, int column,
boolean validRes, boolean validEnd)
{
- g.setColor(STEM_COLOUR);
int sCol = (lastSSX / charWidth)
+ hiddenColumns.visibleToAbsoluteColumn(startRes);
int x1 = lastSSX;
|| row_annotations[column] == null
|| dc != row_annotations[column].secondaryStructure;
+ if (diffupstream || diffdownstream)
+ {
+ // draw glyphline under arrow
+ drawGlyphLine(g, lastSSX, x, y, iconOffset);
+ }
+ g.setColor(STEM_COLOUR);
+
if (column > 0 && Rna.isClosingParenthesis(dc))
{
if (diffupstream)
*/
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;
}
* if annotation ending with an opeing base pair half of the stem,
* display a forward arrow
*/
- 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;
}
}
}
// draw arrow body
- fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 7);
+ unsetAntialias(g);
+ fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 6);
}
void drawNotCanonicalAnnot(Graphics g, Color nonCanColor,
{
// Console.info(nonCanColor);
- g.setColor(nonCanColor);
int sCol = (lastSSX / charWidth)
+ hiddenColumns.visibleToAbsoluteColumn(startRes);
int x1 = lastSSX;
// "+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))
{
{
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;
}
// 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;
}
}
}
// 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
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;
*
* 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)
{
: null;
if (x > -1)
{
+ unsetAntialias(g);
if (activeRow == i)
{
g.setColor(Color.red);
g2d.transform(
AffineTransform.getScaleInstance(fmScaling, 1.0));
}
+ setAntialias(g);
if (column == 0 || row.graph > 0)
{
g2d.drawString(displayChar, 0, 0);
// 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;
}
}
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;
}
}
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;
// 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);
}
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')
{
}
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')
}
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)
{
- fillArc(g, lastSSX, y + 4 + iconOffset, charWidth, 8, 90, 180);
+ drawGlyphLine(g, lastSSX, x, y, iconOffset);
+ }
+ g.setColor(HELIX_COLOUR);
+
+ if (leftEnd)
+ {
+ 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,
{
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;
}
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);
// 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;
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++;
}
{
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")
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;
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);
}
}
}
}
- 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;
}
}
- 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;
+ }
}
git://source.jalview.org / jalview.git / blobdiff