*/
package jalview.renderer;
+import java.awt.BasicStroke;
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.FontMetrics;
+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 java.util.Hashtable;
+
import jalview.analysis.AAFrequency;
import jalview.analysis.CodingUtils;
import jalview.analysis.Rna;
import jalview.analysis.StructureFrequency;
import jalview.api.AlignViewportI;
-import jalview.bin.Jalview;
+import jalview.bin.Cache;
+import jalview.bin.Console;
import jalview.datamodel.AlignmentAnnotation;
import jalview.datamodel.Annotation;
import jalview.datamodel.ColumnSelection;
import jalview.datamodel.HiddenColumns;
import jalview.datamodel.ProfilesI;
+import jalview.renderer.api.AnnotationRendererFactoryI;
+import jalview.renderer.api.AnnotationRowRendererI;
import jalview.schemes.ColourSchemeI;
import jalview.schemes.NucleotideColourScheme;
import jalview.schemes.ResidueProperties;
import jalview.schemes.ZappoColourScheme;
import jalview.util.Platform;
-import java.awt.BasicStroke;
-import java.awt.Color;
-import java.awt.Font;
-import java.awt.FontMetrics;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.Image;
-import java.awt.geom.AffineTransform;
-import java.awt.image.ImageObserver;
-import java.util.BitSet;
-import java.util.Hashtable;
-
public class AnnotationRenderer
{
private static final int UPPER_TO_LOWER = 'a' - 'A'; // 32
private ProfilesI hconsensus;
- private Hashtable[] complementConsensus;
+ private Hashtable<String, Object>[] complementConsensus;
- private Hashtable[] hStrucConsensus;
+ private Hashtable<String, Object>[] hStrucConsensus;
private boolean av_ignoreGapsConsensus;
*/
public void dispose()
{
+ hiddenColumns = null;
hconsensus = null;
complementConsensus = null;
hStrucConsensus = null;
fadedImage = null;
annotationPanel = null;
+ rendererFactoryI = null;
}
void drawStemAnnot(Graphics g, Annotation[] row_annotations, int lastSSX,
* 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)
+ hiddenColumns.visibleToAbsoluteColumn(startRes);
int x1 = lastSSX;
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 (diffupstream || diffdownstream)
+ {
+ // draw glyphline under arrow
+ this.drawGlyphLine(g, row_annotations, lastSSX, x, y, iconOffset,
+ startRes, column, validRes, validEnd);
+ }
+ g.setColor(nonCanColor);
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 },
+ { y + iconOffset + 1, y + 13 + iconOffset,
+ y + 7 + iconOffset },
3);
x1 += 5;
}
// display a forward arrow
if (diffdownstream)
{
- g.fillPolygon(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
- g.fillRect(x1, y + 4 + iconOffset, x2 - x1, 7);
+ unsetAntialias(g);
+ fillRect(g, x1 - 1, y + 4 + iconOffset, x2 - x1 + 1, 6);
}
// public void updateFromAnnotationPanel(FontMetrics annotFM, AlignViewportI
useClip = false;
}
+ rendererFactoryI = AnnotationRendererFactory.getRendererFactory();
updateFromAlignViewport(av);
}
boolean rna = false;
+ private AnnotationRendererFactoryI rendererFactoryI;
+
/**
* Render the annotation rows associated with an alignment.
*
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:
updateFromAwtRenderPanel(annotPanel, av);
fm = g.getFontMetrics();
AlignmentAnnotation[] aa = av.getAlignment().getAlignmentAnnotation();
- int temp = 0;
+ // int temp = 0;
if (aa == null)
{
return false;
boolean validRes = false;
boolean validEnd = false;
boolean labelAllCols = false;
- boolean centreColLabels;
- boolean centreColLabelsDef = av.isCentreColumnLabels();
+ // boolean centreColLabels;
+ // boolean centreColLabelsDef = av.isCentreColumnLabels();
boolean scaleColLabel = false;
final AlignmentAnnotation consensusAnnot = av
.getAlignmentConsensusAnnotation();
.getAlignmentStrucConsensusAnnotation();
final AlignmentAnnotation complementConsensusAnnot = av
.getComplementConsensusAnnotation();
- boolean renderHistogram = true, renderProfile = true,
- normaliseProfile = false, isRNA = rna;
BitSet graphGroupDrawn = new BitSet();
int charOffset = 0; // offset for a label
for (int i = 0; i < aa.length; i++)
{
AlignmentAnnotation row = aa[i];
- isRNA = row.isRNA();
+ boolean renderHistogram = true;
+ boolean renderProfile = false;
+ boolean normaliseProfile = false;
+ boolean isRNA = row.isRNA();
+
+ // check if this is a consensus annotation row and set the display
+ // settings appropriately
+ // TODO: generalise this to have render styles for consensus/profile
+ // data
+ if (row.groupRef != null && row == row.groupRef.getConsensus())
{
- // check if this is a consensus annotation row and set the display
- // settings appropriately
- // TODO: generalise this to have render styles for consensus/profile
- // data
- if (row.groupRef != null && row == row.groupRef.getConsensus())
- {
- renderHistogram = row.groupRef.isShowConsensusHistogram();
- renderProfile = row.groupRef.isShowSequenceLogo();
- normaliseProfile = row.groupRef.isNormaliseSequenceLogo();
- }
- else if (row == consensusAnnot || row == structConsensusAnnot
- || row == complementConsensusAnnot)
- {
- renderHistogram = av_renderHistogram;
- renderProfile = av_renderProfile;
- normaliseProfile = av_normaliseProfile;
- }
- else
- {
- renderHistogram = true;
- // don't need to set render/normaliseProfile since they are not
- // currently used in any other annotation track renderer
- }
+ renderHistogram = row.groupRef.isShowConsensusHistogram();
+ renderProfile = row.groupRef.isShowSequenceLogo();
+ normaliseProfile = row.groupRef.isNormaliseSequenceLogo();
}
+ else if (row == consensusAnnot || row == structConsensusAnnot
+ || row == complementConsensusAnnot)
+ {
+ renderHistogram = av_renderHistogram;
+ renderProfile = av_renderProfile;
+ normaliseProfile = av_normaliseProfile;
+ }
+
Annotation[] row_annotations = row.annotations;
if (!row.visible)
{
continue;
}
- centreColLabels = row.centreColLabels || centreColLabelsDef;
+ // centreColLabels = row.centreColLabels || centreColLabelsDef;
labelAllCols = row.showAllColLabels;
scaleColLabel = row.scaleColLabel;
lastSS = ' ';
: null;
if (x > -1)
{
+ unsetAntialias(g);
if (activeRow == i)
{
g.setColor(Color.red);
{
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));
}
+ setAntialias(g);
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)
if (x > -1)
{
- int nb_annot = x - temp;
- // System.out.println("\t type :"+lastSS+"\t x :"+x+"\t nbre
+ // int nb_annot = x - temp;
+ // Console.info("\t type :"+lastSS+"\t x
+ // :"+x+"\t nbre
// annot :"+nb_annot);
switch (lastSS)
{
case ')': // and opposite direction
drawStemAnnot(g, row_annotations, lastSSX, x, y,
iconOffset, startRes, column, validRes, validEnd);
- temp = x;
+ // temp = x;
break;
case 'H':
drawNotCanonicalAnnot(g, nonCanColor, row_annotations,
lastSSX, x, y, iconOffset, startRes, column,
validRes, validEnd);
- temp = x;
+ // temp = x;
break;
default:
- g.setColor(Color.gray);
+ unsetAntialias(g);
+ g.setColor(GLYPHLINE_COLOR);
g.fillRect(lastSSX, y + 6 + iconOffset,
(x * charWidth) - lastSSX, 2);
- temp = x;
+ g.drawRect(lastSSX, y + 6 + iconOffset,
+ (x * charWidth) - lastSSX - 1, 2);
+ // temp = x;
break;
}
}
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);
row.graphMin, row.graphMax, y, renderHistogram,
renderProfile, normaliseProfile);
}
+ else
+ {
+ AnnotationRowRendererI renderer = rendererFactoryI
+ .getRendererFor(row);
+ if (renderer != null)
+ {
+ renderer.renderRow(g, charWidth, charHeight, hasHiddenColumns,
+ av, hiddenColumns, columnSelection, row,
+ row_annotations, startRes, endRes, row.graphMin,
+ row.graphMax, y);
+ }
+ if (debugRedraw)
+ {
+ if (renderer == null)
+ {
+ System.err
+ .println("No renderer found for " + row.toString());
+ }
+ else
+ {
+ Console.warn(
+ "rendered with " + renderer.getClass().toString());
+ }
+ }
+
+ }
}
}
else
{
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;
public static final Color STEM_COLOUR = Color.blue;
- private Color sdNOTCANONICAL_COLOUR;
+ // 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)
{
+ unsetAntialias(g);
g.setColor(GLYPHLINE_COLOR);
g.fillRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - lastSSX, 2);
+ g.drawRect(lastSSX, y + 6 + iconOffset, (x * charWidth) - lastSSX - 1,
+ 2);
}
void drawSheetAnnot(Graphics g, Annotation[] row,
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')
{
- g.fillRect(lastSSX, y + 4 + iconOffset, (x * charWidth) - lastSSX - 4,
- 7);
- g.fillPolygon(
+ // draw the glyphline underneath
+ drawGlyphLine(g, row, lastSSX, x, y, iconOffset, startRes, column,
+ validRes, validEnd);
+ 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
{
- g.fillRect(lastSSX, y + 4 + iconOffset, (x + 1) * charWidth - lastSSX,
- 7);
+ 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 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 - 1, 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,
- 0, 0);
+ fillRoundRect(g, lastSSX, y + 4 + iconOffset, x2 - x1 - ofs, 8, 0,
+ 0);
}
if (!validRes || row[column] == null
|| row[column].secondaryStructure != 'H')
else
{
// g.setColor(Color.magenta);
- g.fillRoundRect(lastSSX + ofs, y + 4 + iconOffset,
- x2 - x1 - ofs + 1, 8, 0, 0);
+ fillRoundRect(g, lastSSX + ofs, y + 4 + iconOffset, x2 - x1 - ofs,
+ 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,
- 8, 270, 180);
+ fillArc(g, (x * charWidth) - charWidth - 1, 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,
y2 = y - (int) ((0 - min / range) * graphHeight);
}
+ setAntialias(g);
g.setColor(Color.gray);
g.drawLine(x - charWidth, y2, (eRes - sRes + 1) * charWidth, y2);
break;
}
- if (aa_annotations[column] == null
- || aa_annotations[column - 1] == null)
+ if (aa_annotations[column] == null)
{
x++;
continue;
g.setColor(aa_annotations[column].colour);
}
+ if (aa_annotations[column - 1] == null
+ && aa_annotations.length > column + 1
+ && aa_annotations[column + 1] == null)
+ {
+ // standalone value
+ y1 = y - (int) (((aa_annotations[column].value - min) / range)
+ * graphHeight);
+ g.drawLine(x * charWidth + charWidth / 4, y1,
+ x * charWidth + 3 * charWidth / 4, y1);
+ x++;
+ continue;
+ }
+
+ if (aa_annotations[column - 1] == null)
+ {
+ x++;
+ continue;
+ }
+
y1 = y - (int) (((aa_annotations[column - 1].value - min) / range)
* graphHeight);
y2 = y - (int) (((aa_annotations[column].value - min) / range)
{
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
boolean isStructureProfile = profl[0] == AlignmentAnnotation.STRUCTURE_PROFILE;
boolean isCdnaProfile = profl[0] == AlignmentAnnotation.CDNA_PROFILE;
float ht = normaliseProfile ? y - _aa.graphHeight : y1;
- final double normaliseFactor = normaliseProfile ? _aa.graphHeight : (y2 - y1);
+ final double normaliseFactor = normaliseProfile ? _aa.graphHeight
+ : (y2 - y1);
/**
* Render a single base for a sequence profile, a base pair for
// 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();
s = new String(dc);
}
// next profl[] position is profile % for the character(s)
-
- double newHeight = normaliseFactor * scale * profl[c++];
+
+ int percent = profl[c++];
+ if (percent == 0)
+ {
+ // failsafe in case a count rounds down to 0%
+ continue;
+ }
+ double newHeight = normaliseFactor * scale * percent;
/*
* Set character colour as per alignment colour scheme; use the
// (int)(scl));
// g.setColor(profcolour.findColour(dc[0]).darker());
- double sx = 1f * charWidth / fm.charsWidth(dc, 0, dc.length);
+ double sx = 1f * charWidth / fm.charsWidth(dc, 0, dc.length);
double sy = newHeight / asc;
- double newAsc = asc * sy;
+ double newAsc = asc * sy;
double newDec = dec * sy;
// it is not necessary to recalculate lm for the new font.
// note: lm.getBaselineOffsets()[lm.getBaselineIndex()]) must be 0
// int hght = (int) (ht + (newAsc - newDec);
// - lm.getBaselineOffsets()[lm.getBaselineIndex()]));
- if (Jalview.isJS())
+ if (Platform.isJS())
{
/*
* SwingJS does not implement font.deriveFont()
ht2 += newHeight;
}
else
+ /**
+ * Java only
+ *
+ * @j2sIgnore
+ */
{
- /*
- * Java ('normal') method is to scale the font to fit
- */
+ // Java ('normal') method is to scale the font to fit
+
final int hght = (int) (ht + (newAsc - newDec));
Font font = ofont
.deriveFont(AffineTransform.getScaleInstance(sx, sy));
g.setFont(font);
g.drawChars(dc, 0, dc.length, x * charWidth, hght);
+ g.setFont(ofont);
+
ht += newHeight;
}
}
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(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);
{
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)
+ {
+ unsetAntialias(g);
+ g.fillPolygon(xpoints, ypoints, 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)
+ {
+ 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 / blobdiff