import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
+import java.awt.RenderingHints;
import java.awt.geom.AffineTransform;
import java.awt.image.ImageObserver;
import java.util.BitSet;
import jalview.analysis.Rna;
import jalview.analysis.StructureFrequency;
import jalview.api.AlignViewportI;
+import jalview.bin.Cache;
+import jalview.bin.Console;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.Annotation;
import jalview.datamodel.ColumnSelection;
* if new annotation with a closing base pair half of the stem,
* display a backward arrow
*/
- g.fillPolygon(new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
+ fillPolygon(g, new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
new int[]
{ y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
3);
* if annotation ending with an opeing base pair half of the stem,
* display a forward arrow
*/
- g.fillPolygon(new int[] { x2 - 5, x2 - 5, x2 },
+ fillPolygon(g, new int[] { x2 - 5, x2 - 5, x2 },
new int[]
{ y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
3);
}
}
// draw arrow body
- g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
+ fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 7);
}
void drawNotCanonicalAnnot(Graphics g, Color nonCanColor,
int iconOffset, int startRes, int column, boolean validRes,
boolean validEnd)
{
- // System.out.println(nonCanColor);
+ // Console.info(nonCanColor);
g.setColor(nonCanColor);
int sCol = (lastSSX / charWidth)
boolean diffdownstream = !validRes || !validEnd
|| row_annotations[column] == null
|| !dc.equals(row_annotations[column].displayCharacter);
- // System.out.println("Column "+column+" diff up: "+diffupstream+"
+ // Console.info("Column "+column+" diff up:
+ // "+diffupstream+"
// down:"+diffdownstream);
// If a closing base pair half of the stem, display a backward arrow
if (column > 0 && Rna.isClosingParenthesis(dc))
// if (validRes && column>1 && row_annotations[column-2]!=null &&
// dc.equals(row_annotations[column-2].displayCharacter))
{
- g.fillPolygon(new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
+ fillPolygon(g, new int[] { lastSSX + 5, lastSSX + 5, lastSSX },
new int[]
{ y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
3);
// display a forward arrow
if (diffdownstream)
{
- g.fillPolygon(new int[] { x2 - 5, x2 - 5, x2 },
+ fillPolygon(g, new int[] { x2 - 5, x2 - 5, x2 },
new int[]
{ y + iconOffset, y + 14 + iconOffset, y + 8 + iconOffset },
3);
}
}
// draw arrow body
- g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
+ fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 7);
}
// 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))
+ {
+ g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+ RenderingHints.VALUE_ANTIALIAS_ON);
+ g2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
+ RenderingHints.VALUE_STROKE_PURE);
+ }
+
long stime = System.currentTimeMillis();
boolean usedFaded = false;
// NOTES:
{
if (columnSelection.contains(column))
{
- g.fillRect(x * charWidth, y, charWidth, charHeight);
+ fillRect(g, x * charWidth, y, charWidth, charHeight);
}
}
}
if (row.getInvalidStrucPos() > x)
{
g.setColor(Color.orange);
- g.fillRect(x * charWidth, y, charWidth, charHeight);
+ fillRect(g, x * charWidth, y, charWidth, charHeight);
}
else if (row.getInvalidStrucPos() == x)
{
g.setColor(Color.orange.darker());
- g.fillRect(x * charWidth, y, charWidth, charHeight);
+ fillRect(g, x * charWidth, y, charWidth, charHeight);
}
if (validCharWidth && validRes && displayChar != null
&& (displayChar.length() > 0))
{
- Graphics2D gg = ((Graphics2D) g);
+ // Graphics2D gg = (g);
float fmWidth = fm.charsWidth(displayChar.toCharArray(), 0,
displayChar.length());
if (row_annotations[column].colour == null)
{
- gg.setColor(Color.black);
+ g2d.setColor(Color.black);
}
else
{
- gg.setColor(row_annotations[column].colour);
+ g2d.setColor(row_annotations[column].colour);
}
/*
/*
* translate to drawing position _before_ applying any scaling
*/
- gg.translate(xPos, yPos);
+ g2d.translate(xPos, yPos);
if (scaledToFit)
{
/*
* use a scaling transform to make the label narrower
* (JalviewJS doesn't have Font.deriveFont(AffineTransform))
*/
- gg.transform(
+ g2d.transform(
AffineTransform.getScaleInstance(fmScaling, 1.0));
}
if (column == 0 || row.graph > 0)
{
- gg.drawString(displayChar, 0, 0);
+ g2d.drawString(displayChar, 0, 0);
}
else if (row_annotations[column - 1] == null || (labelAllCols
|| !displayChar.equals(
|| (displayChar.length() < 2
&& row_annotations[column].secondaryStructure == ' ')))
{
- gg.drawString(displayChar, 0, 0);
+ g2d.drawString(displayChar, 0, 0);
}
if (scaledToFit)
{
* undo scaling before translating back
* (restoring saved transform does NOT work in JS PDFGraphics!)
*/
- gg.transform(AffineTransform
+ g2d.transform(AffineTransform
.getScaleInstance(1D / fmScaling, 1.0));
}
- gg.translate(-xPos, -yPos);
+ g2d.translate(-xPos, -yPos);
}
}
if (row.hasIcons)
{
// int nb_annot = x - temp;
- // System.out.println("\t type :"+lastSS+"\t x :"+x+"\t nbre
+ // Console.info("\t type :"+lastSS+"\t x
+ // :"+x+"\t nbre
// annot :"+nb_annot);
switch (lastSS)
{
// temp = x;
break;
default:
- g.setColor(Color.gray);
+ g.setColor(GLYPHLINE_COLOR);
g.fillRect(lastSSX, y + 6 + iconOffset,
(x * charWidth) - lastSSX, 2);
// temp = x;
case 'y':
case 'Z':
case 'z':
- // System.out.println(lastSS);
+ // Console.info(lastSS);
Color nonCanColor = getNotCanonicalColor(lastSS);
drawNotCanonicalAnnot(g, nonCanColor, row_annotations, lastSSX,
x, y, iconOffset, startRes, column, validRes, validEnd);
}
else
{
- System.err.println(
+ Console.warn(
"rendered with " + renderer.getClass().toString());
}
}
{
if (clipst)
{
- System.err.println(
- "Start clip at : " + yfrom + " (index " + f_i + ")");
+ Console.warn("Start clip at : " + yfrom + " (index " + f_i + ")");
}
if (clipend)
{
- System.err.println(
- "End clip at : " + yto + " (index " + f_to + ")");
+ Console.warn("End clip at : " + yto + " (index " + f_to + ")");
}
}
;
- System.err.println("Annotation Rendering time:"
+ Console.warn("Annotation Rendering time:"
+ (System.currentTimeMillis() - stime));
}
;
public static final Color GLYPHLINE_COLOR = Color.gray;
- public static final Color SHEET_COLOUR = Color.green;
+ public static final Color SHEET_COLOUR = Color.green.darker();
public static final Color HELIX_COLOUR = Color.red;
boolean validEnd)
{
g.setColor(GLYPHLINE_COLOR);
+ unsetAntiAlias(g);
g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - lastSSX, 2);
}
if (!validEnd || !validRes || row == null || row[column] == null
|| row[column].secondaryStructure != 'E')
{
- g.fillRect(lastSSX, y + 4 + iconOffset, (x * charWidth) - lastSSX - 4,
- 7);
- g.fillPolygon(
+ fillRect(g, lastSSX, y + 4 + iconOffset,
+ (x * charWidth) - lastSSX - 4, 6);
+ fillPolygon(g,
new int[]
{ (x * charWidth) - 4, (x * charWidth) - 4, (x * charWidth) },
new int[]
}
else
{
- g.fillRect(lastSSX, y + 4 + iconOffset, (x + 1) * charWidth - lastSSX,
- 7);
+ fillRect(g, lastSSX, y + 4 + iconOffset,
+ (x + 1) * charWidth - lastSSX, 6);
}
}
int x1 = lastSSX;
int x2 = (x * charWidth);
+ y--;
+
if (USE_FILL_ROUND_RECT)
{
int ofs = charWidth / 2;
// Off by 1 offset when drawing rects and ovals
// to offscreen image on the MAC
- g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1, 8, 8, 8);
+ fillRoundRect(g, lastSSX, y + 4 + iconOffset, x2 - x1, 8, 8, 8);
if (sCol == 0 || row[sCol - 1] == null
|| row[sCol - 1].secondaryStructure != 'H')
{
else
{
// g.setColor(Color.orange);
- g.fillRoundRect(lastSSX, y + 4 + iconOffset, x2 - x1 - ofs + 1, 8,
+ fillRoundRect(g, lastSSX, y + 4 + iconOffset, x2 - x1 - ofs + 1, 8,
0, 0);
}
if (!validRes || row[column] == null
else
{
// g.setColor(Color.magenta);
- g.fillRoundRect(lastSSX + ofs, y + 4 + iconOffset,
+ fillRoundRect(g, lastSSX + ofs, y + 4 + iconOffset,
x2 - x1 - ofs + 1, 8, 0, 0);
}
if (sCol == 0 || row[sCol - 1] == null
|| row[sCol - 1].secondaryStructure != 'H')
{
- g.fillArc(lastSSX, y + 4 + iconOffset, charWidth, 8, 90, 180);
+ fillArc(g, lastSSX, y + 4 + iconOffset, charWidth, 8, 90, 180);
x1 += charWidth / 2;
}
if (!validRes || row[column] == null
|| row[column].secondaryStructure != 'H')
{
- g.fillArc((x * charWidth) - charWidth, y + 4 + iconOffset, charWidth,
+ fillArc(g, (x * charWidth) - charWidth, y + 4 + iconOffset, charWidth,
8, 270, 180);
x2 -= charWidth / 2;
}
- g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 8);
+ fillRect(g, x1, y + 4 + iconOffset, x2 - x1, 8);
}
void drawLineGraph(Graphics g, AlignmentAnnotation _aa,
{
if (y1 - y2 > 0)
{
- g.fillRect(x * charWidth, y2, charWidth, y1 - y2);
+ fillRect(g, x * charWidth, y2, charWidth, y1 - y2);
}
else
{
- g.fillRect(x * charWidth, y1, charWidth, y2 - y1);
+ fillRect(g, x * charWidth, y1, charWidth, y2 - y1);
}
}
// draw profile if available
// lm is not necessary - we can just use fm - could be off by no more
// than 0.5 px
// LineMetrics lm = g.getFontMetrics(ofont).getLineMetrics("Q", g);
- // System.out.println(asc + " " + dec + " " + (asc - lm.getAscent())
+ // Console.info(asc + " " + dec + " " + (asc -
+ // lm.getAscent())
// + " " + (dec - lm.getDescent()));
double asc = fm.getAscent();
{
eRes = Math.min(eRes, aa_annotations.length);
g.setColor(Color.white);
- g.fillRect(0, 0, width, y);
+ fillRect(g, 0, 0, width, y);
g.setColor(new Color(0, 0, 180));
int x = 0, height;
height = y;
}
- g.fillRect(x, y - height, charWidth, height);
+ fillRect(g, x, y - height, charWidth, height);
}
x += charWidth;
}
return new Color(0, 80, 255);
default:
- System.out.println("This is not a interaction : " + lastss);
+ Console.info("This is not a interaction : " + lastss);
return null;
}
}
+
+ private static void fillPolygon(Graphics g, int[] xpoints, int[] ypoints,
+ int n)
+ {
+ 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)
+ {
+ setAntiAlias(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)
+ {
+ 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)
+ {
+ setAntiAlias(g);
+ g.fillArc(a, b, c, d, e, f);
+ g.drawArc(a, b, c, d, e, f);
+ }
+
+ private static void setAntiAlias(Graphics g)
+ {
+ if (Cache.getDefault("ANTI_ALIAS", true))
+ {
+ Graphics2D g2d = (Graphics2D) g;
+ g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+ RenderingHints.VALUE_ANTIALIAS_ON);
+ }
+ }
+
+ private static void unsetAntiAlias(Graphics g)
+ {
+ Graphics2D g2d = (Graphics2D) g;
+ g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+ RenderingHints.VALUE_ANTIALIAS_OFF);
+ }
}
git://source.jalview.org / jalview.git / commitdiff