下面列出了怎么用java.awt.RenderingHints的API类实例代码及写法，或者点击链接到github查看源代码。
@Override
public BufferedImage call() throws Exception {
BufferedImage bi = new BufferedImage(80, 60,
BufferedImage.TYPE_INT_RGB);
Graphics2D g = bi.createGraphics();
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING,
RenderingHints.VALUE_COLOR_RENDER_QUALITY);
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g.setRenderingHint(RenderingHints.KEY_RENDERING,
RenderingHints.VALUE_RENDER_QUALITY);
g.transform(TransformUtils.createAffineTransform(new Dimension(
sampleImage.getWidth(), sampleImage.getHeight()),
new Dimension(bi.getWidth(), bi.getHeight())));
g.drawImage(sampleImage, 0, 0, null);
g.dispose();
return bi;
}
@Override
public CompositeContext createContext(ColorModel srcColorModel,
ColorModel dstColorModel,
RenderingHints arg2) {
switch (mode) {
case MULTIPLY:
return new MultiplyContext();
// Modes with significant creation overhead (lookup tables). Cache those
case SOFT_LIGHT:
CompositeContext ctx = cache.get(Mode.SOFT_LIGHT);
if (ctx == null) {
ctx = new BlendContext(mode, color);
cache.put(Mode.SOFT_LIGHT, ctx);
}
return ctx;
default:
return new BlendContext(mode, color);
}
}
public void closePath(){
if(this.pathEmpty){
System.out.println("Warning: Empty Path!");
}
if( (this.style & PATH_DRAW) != 0){
this.gc.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
this.gc.setColor(this.foreground.getHandle(this.alpha));
this.gc.draw(this.path);
}
if( (this.style & PATH_FILL) != 0){
this.gc.setColor(this.background.getHandle(this.alpha));
this.gc.fill(this.path);
}
this.style = 0;
this.path = null;
this.pathEmpty = true;
this.setAntialias( false );
}
private void reportFailure(String id, Shape good, Shape bad) {
Rectangle2D r = good.getBounds2D();
r.add(bad.getBounds2D());
BufferedImage image = new BufferedImage(500, 500,
BufferedImage.TYPE_INT_ARGB);
Graphics2D g = image.createGraphics();
g.transform(RectangularTransform.create(r,
new Rectangle(0, 0, image.getWidth(), image.getHeight())));
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g.setColor(Color.blue);
g.fill(good);
g.setColor(new Color(255, 0, 0, 128));
g.fill(bad);
g.dispose();
printStream.println("the resulting shape for \"" + id
+ "\" wasn't correct.");
try {
ImageIO.write(image, "png", new File("comparison " + (ctr++)
+ ".png"));
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void addToResources(EditableResources e) {
if(logicalName == null) {
logicalName = "Arial" + getIdentity() + size;
createBitmap = false;
} else {
if(logicalName.indexOf('-') < 0) {
logicalName += getIdentity() + size;
}
}
Object aa;
if(antiAliasing) {
aa = RenderingHints.VALUE_TEXT_ANTIALIAS_ON;
} else {
aa = RenderingHints.VALUE_TEXT_ANTIALIAS_OFF;
}
EditorFont f = new EditorFont(Font.createSystemFont(systemFace, systemStyle, systemSize),
null, logicalName, createBitmap, aa, charset);
e.setFont(getName(), f);
}
/**
* Constructor for PDFGraphics2D.
*/
public PdfGraphics2D( final PdfContentByte cb, final float width, final float height,
final PdfOutputProcessorMetaData metaData ) {
this.metaData = metaData;
dg2.setRenderingHint( RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON );
setRenderingHint( RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON );
this.transform = new AffineTransform();
paint = Color.black;
background = Color.white;
setFont( new Font( "sanserif", Font.PLAIN, 12 ) );
this.cb = cb;
cb.saveState();
this.width = width;
this.height = height;
clip = new Area( new Rectangle2D.Float( 0, 0, width, height ) );
clip( clip );
oldStroke = strokeOne;
stroke = strokeOne;
originalStroke = strokeOne;
setStrokeDiff( stroke, null );
cb.saveState();
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g2.setColor(Color.RED);
int x = 0;
int y = 0;
Dimension dimension = getSize();
int dim = Math.min(dimension.width, dimension.height) / 2;
if(position != null) {
x = position.x * dim / maxSize;
y = position.y * dim / maxSize;
}
g2.fillOval((dimension.width / 2) + x - (POINT_DIM / 2), (dimension.height / 2) - y - (POINT_DIM / 2), POINT_DIM, POINT_DIM);
// g2.drawRect(0, 0, dimension.width - 1, dimension.height - 1);
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D)g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
int w = getWidth();
int h = getHeight();
g2.clearRect(0, 0, w, h);
g2.setPaint(Color.black);
g2.drawRect(0, 0, w - 1, h - 1);
for (Vector2D point : points) {
Vector2D p = transform(point, w, h);
double[] arr = p.toArray();
g2.draw(new Rectangle2D.Double(arr[0] - 1, arr[1] - 1, 2, 2));
}
}
/**
* Provides serialization support.
*
* @param stream the input stream.
*
* @throws IOException if there is an I/O error.
* @throws ClassNotFoundException if there is a classpath problem.
*/
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException {
stream.defaultReadObject();
this.borderStroke = SerialUtilities.readStroke(stream);
this.borderPaint = SerialUtilities.readPaint(stream);
this.backgroundPaint = SerialUtilities.readPaint(stream);
this.progressListeners = new EventListenerList();
this.changeListeners = new EventListenerList();
this.renderingHints = new RenderingHints(
RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
// register as a listener with sub-components...
if (this.title != null) {
this.title.addChangeListener(this);
}
for (int i = 0; i < getSubtitleCount(); i++) {
getSubtitle(i).addChangeListener(this);
}
this.plot.addChangeListener(this);
}
private static BufferedImage createBufferedImage(final boolean aa) {
final BufferedImage bi = new BufferedImage(SIZE, SIZE,
BufferedImage.TYPE_INT_RGB);
final Graphics2D bg = bi.createGraphics();
bg.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
aa ? RenderingHints.VALUE_ANTIALIAS_ON
: RenderingHints.VALUE_ANTIALIAS_OFF);
bg.setColor(Color.RED);
bg.fillRect(0, 0, SIZE, SIZE);
bg.translate(100, 100);
bg.rotate(Math.toRadians(90));
bg.setColor(Color.BLACK);
bg.setFont(bg.getFont().deriveFont(20.0f));
bg.drawString("MMMMMMMMMMMMMMMM", 0, 0);
bg.dispose();
return bi;
}
/**
* Return the interpolation rendering hint to use. This will not return
* null. If this is undefined, then the antialiasing and rendering hints are
* consulted (which will return either NEAREST_NEIGHBOR or BILINEAR). If
* nothing is defined then this returns BILINEAR.
*/
protected Object getInterpolationRenderingHint() {
Object v = renderingHints.get(RenderingHints.KEY_INTERPOLATION);
if (v != null)
return v;
v = renderingHints.get(RenderingHints.KEY_ANTIALIASING);
if (RenderingHints.VALUE_ANTIALIAS_ON.equals(v)) {
return RenderingHints.VALUE_INTERPOLATION_BILINEAR;
} else if (RenderingHints.VALUE_ANTIALIAS_OFF.equals(v)) {
return RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
}
v = renderingHints.get(RenderingHints.KEY_RENDERING);
if (RenderingHints.VALUE_RENDER_QUALITY.equals(v)) {
return RenderingHints.VALUE_INTERPOLATION_BILINEAR;
} else if (RenderingHints.VALUE_RENDER_SPEED.equals(v)) {
return RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
}
// nothing is defined:
return RenderingHints.VALUE_INTERPOLATION_BILINEAR;
}
private static void render(Graphics g, int w, int h, boolean useNonOpaque) {
if (useNonOpaque) {
Graphics2D g2d = (Graphics2D)g;
GradientPaint p =
new GradientPaint(0.0f, 0.0f,
new Color(rnd.nextInt(0xffffff)),
w, h,
new Color(rnd.nextInt(0xff),
rnd.nextInt(0xff),
rnd.nextInt(0xff), 0),
true);
g2d.setPaint(p);
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g2d.fillOval(0, 0, w, h);
} else {
g.setColor(new Color(rnd.nextInt(0xffffff)));
g.fillRect(0, 0, w, h);
}
}
public void render(int width, int height, ClassNode rootNode, Graphics g) {
image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
Graphics2D imageG2d = (Graphics2D)image.getGraphics();
imageG2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
imageG2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
imageG2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
imageG2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
imageG2d.setComposite(AlphaComposite.Src);
imageG2d.setColor(GuiMode.getTheme().getBackgroundColor());
imageG2d.fillRect(0, 0, width, height);
int graphWidth = width - MARGIN * 2;
int graphHeight = height - MARGIN * 2;
imageG2d.translate(MARGIN, MARGIN);
int size = Math.min(graphWidth, graphHeight);
renderNode(graphWidth, graphHeight, size, 0, 360, rootNode, imageG2d, 1, PALETTE);
imageG2d.dispose();
g.drawImage(image, 0, 0, null);
g.dispose();
}
/**
* Constructs a new ColorConvertOp from a ColorSpace object.
* The RenderingHints argument may be null. This
* Op can be used only with BufferedImages, and is primarily useful
* when the {@link #filter(BufferedImage, BufferedImage) filter}
* method is invoked with a destination argument of null.
* In that case, the ColorSpace defines the destination color space
* for the destination created by the filter method. Otherwise, the
* ColorSpace defines an intermediate space to which the source is
* converted before being converted to the destination space.
* @param cspace defines the destination <code>ColorSpace</code> or an
* intermediate <code>ColorSpace</code>
* @param hints the <code>RenderingHints</code> object used to control
* the color conversion, or <code>null</code>
* @throws NullPointerException if cspace is null
*/
public ColorConvertOp (ColorSpace cspace, RenderingHints hints)
{
if (cspace == null) {
throw new NullPointerException("ColorSpace cannot be null");
}
if (cspace instanceof ICC_ColorSpace) {
profileList = new ICC_Profile [1]; /* 1 profile in the list */
profileList [0] = ((ICC_ColorSpace) cspace).getProfile();
}
else {
CSList = new ColorSpace[1]; /* non-ICC case: 1 ColorSpace in list */
CSList[0] = cspace;
}
this.hints = hints;
}
/**
* Draws the gridlines for the plot, if they are visible.
*
* @param g2 the graphics device.
* @param dataArea the data area.
* @param ticks the ticks.
*/
protected void drawDomainGridlines(Graphics2D g2, Rectangle2D dataArea,
List ticks) {
if (!isDomainGridlinesVisible()) {
return;
}
Object saved = g2.getRenderingHint(RenderingHints.KEY_STROKE_CONTROL);
g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
RenderingHints.VALUE_STROKE_NORMALIZE);
Iterator iterator = ticks.iterator();
while (iterator.hasNext()) {
ValueTick tick = (ValueTick) iterator.next();
double v = this.domainAxis.valueToJava2D(tick.getValue(),
dataArea, RectangleEdge.BOTTOM);
Line2D line = new Line2D.Double(v, dataArea.getMinY(), v,
dataArea.getMaxY());
g2.setPaint(getDomainGridlinePaint());
g2.setStroke(getDomainGridlineStroke());
g2.draw(line);
}
g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, saved);
}
BufferedImage drawText(boolean doGV) {
int w = 400;
int h = 50;
BufferedImage bi = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
Graphics2D g = bi.createGraphics();
g.setColor(Color.white);
g.fillRect(0,0,w,h);
g.setColor(Color.black);
Font f = helvFont.deriveFont(Font.PLAIN, 40);
g.setFont(f);
int x = 5;
int y = h - 10;
if (doGV) {
FontRenderContext frc = new FontRenderContext(null, true, true);
GlyphVector gv = f.createGlyphVector(frc, codes);
g.drawGlyphVector(gv, 5, y);
} else {
g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
g.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
RenderingHints.VALUE_FRACTIONALMETRICS_ON);
g.drawString(str, x, y);
}
return bi;
}
public BufferedImage convertToColorSpace(final BufferedImage bi, final ColorSpace to) {
final ColorSpace from = bi.getColorModel().getColorSpace();
final RenderingHints hints = new RenderingHints(RenderingHints.KEY_RENDERING,
RenderingHints.VALUE_RENDER_QUALITY);
hints.put(RenderingHints.KEY_COLOR_RENDERING,
RenderingHints.VALUE_COLOR_RENDER_QUALITY);
hints.put(RenderingHints.KEY_DITHERING,
RenderingHints.VALUE_DITHER_ENABLE);
final ColorConvertOp op = new ColorConvertOp(from, to, hints);
BufferedImage result = op.filter(bi, null);
result = relabelColorSpace(result, to);
return result;
}
public synchronized void paint(Graphics g)
{
long time = System.nanoTime();
update( (time - currentTime) * 0.000000001f );
currentTime = time;
BufferedImage buffer = getBuffer();
Graphics2D gr = buffer.createGraphics();
gr.setColor( getBackground() );
gr.clearRect( 0, 0, buffer.getWidth(), buffer.getHeight() );
gr.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
draw( gr );
g.drawImage( buffer, 0, 0, this );
}
@Override
public java.awt.PaintContext createContext(final ColorModel COLOR_MODEL,
final Rectangle DEVICE_BOUNDS,
final Rectangle2D USER_BOUNDS,
final AffineTransform TRANSFORM,
final RenderingHints RENDERING_HINTS) {
final Point2D TRANSFORMED_CENTER = TRANSFORM.transform(CENTER, null);
final Point2D TRANSFORMED_RADIUS_XY = TRANSFORM.deltaTransform(RADIUS_X_Y, null);
return new OvalGradientContext(TRANSFORMED_CENTER, TRANSFORMED_RADIUS_XY, FRACTIONS, COLORS);
}
public static BufferedImage createResizedImage(Image image,
int width, int height) {
BufferedImage scaled = new BufferedImage(width, height,
BufferedImage.TYPE_INT_ARGB);
Graphics2D g = scaled.createGraphics();
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g.drawImage(image, 0, 0, width, height, null);
g.dispose();
return scaled;
}
private void putAATextInfo( UIDefaults defaults ) {
if( SystemInfo.IS_JAVA_9_OR_LATER ) {
Object desktopHints = Toolkit.getDefaultToolkit().getDesktopProperty( DESKTOPFONTHINTS );
if( desktopHints instanceof Map ) {
@SuppressWarnings( "unchecked" )
Map<Object, Object> hints = (Map<Object, Object>) desktopHints;
Object aaHint = hints.get( RenderingHints.KEY_TEXT_ANTIALIASING );
if( aaHint != null &&
aaHint != RenderingHints.VALUE_TEXT_ANTIALIAS_OFF &&
aaHint != RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT )
{
defaults.put( RenderingHints.KEY_TEXT_ANTIALIASING, aaHint );
defaults.put( RenderingHints.KEY_TEXT_LCD_CONTRAST,
hints.get( RenderingHints.KEY_TEXT_LCD_CONTRAST ) );
}
}
} else {
// Java 8
try {
Object key = Class.forName( "sun.swing.SwingUtilities2" )
.getField( "AA_TEXT_PROPERTY_KEY" )
.get( null );
Object value = Class.forName( "sun.swing.SwingUtilities2$AATextInfo" )
.getMethod( "getAATextInfo", boolean.class )
.invoke( null, true );
defaults.put( key, value );
} catch( Exception ex ) {
Logger.getLogger( FlatLaf.class.getName() ).log( Level.SEVERE, null, ex );
throw new RuntimeException( ex );
}
}
}
public static final void draw(Shape shape, AffineTransform at,
BufferedImage bi, boolean showControlPoints) {
clear(bi);
Graphics2D g = bi.createGraphics();
g.setColor(Color.black);
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g.fill(new BasicStroke(1).createStrokedShape(at
.createTransformedShape(shape)));
if (showControlPoints) {
PathIterator i;
double[] coords = new double[6];
i = shape.getPathIterator(at);
while (i.isDone() == false) {
int k = i.currentSegment(coords);
if (k == PathIterator.SEG_QUADTO
|| k == PathIterator.SEG_CUBICTO) {
g.setColor(Color.blue);
g.fill(new Rectangle2D.Double(coords[0] - 1, coords[1] - 1,
2, 2));
}
if (k == PathIterator.SEG_CUBICTO) {
g.setColor(Color.green);
g.fill(new Rectangle2D.Double(coords[2] - 1, coords[3] - 1,
2, 2));
}
i.next();
}
}
g.dispose();
}
private void drawSelectedRoundBorder(Graphics g, Color aColor) {
final Graphics2D g2d = (Graphics2D) g;
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2d.setStroke(DEFAULT_BORDER_STROKE);
g2d.setColor(aColor);
g2d.drawRoundRect(1, 1, getWidth()-3, getHeight()-3, 16, 16);
}
/**
* Draws a line perpendicular to the domain axis.
*
* @param g2 the graphics device.
* @param plot the plot.
* @param axis the value axis.
* @param dataArea the area for plotting data (not yet adjusted for any 3D
* effect).
* @param value the value at which the grid line should be drawn.
* @param paint the paint (<code>null</code> not permitted).
* @param stroke the stroke (<code>null</code> not permitted).
*
* @since 1.0.5
*/
public void drawDomainLine(Graphics2D g2, XYPlot plot, ValueAxis axis,
Rectangle2D dataArea, double value, Paint paint, Stroke stroke) {
Range range = axis.getRange();
if (!range.contains(value)) {
return;
}
PlotOrientation orientation = plot.getOrientation();
Line2D line = null;
double v = axis.valueToJava2D(value, dataArea,
plot.getDomainAxisEdge());
if (orientation.isHorizontal()) {
line = new Line2D.Double(dataArea.getMinX(), v, dataArea.getMaxX(),
v);
} else if (orientation.isVertical()) {
line = new Line2D.Double(v, dataArea.getMinY(), v,
dataArea.getMaxY());
}
g2.setPaint(paint);
g2.setStroke(stroke);
Object saved = g2.getRenderingHint(RenderingHints.KEY_STROKE_CONTROL);
g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
RenderingHints.VALUE_STROKE_NORMALIZE);
g2.draw(line);
g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, saved);
}
/**
* High-quality image scaling.
*/
private BufferedImage scaleImage(BufferedImage image, int width, int height)
{
BufferedImage image2 = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
Graphics2D g = image2.createGraphics();
if (getInterpolate())
{
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
}
g.drawImage(image, 0, 0, width, height, 0, 0, image.getWidth(), image.getHeight(), null);
g.dispose();
return image2;
}
@Override
public void paintComponent(Graphics g) {
if (AppPreferences.ANTI_ALIASING.getBoolean()) {
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
}
if (dragging) {
g.setColor(DRAG_COLOR);
g.fillRect(0, 0, getWidth(), getHeight());
}
}
public static void testFontOfSize(float sz, Object textHint) {
BufferedImage bi = new BufferedImage(200, 200,
BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = (Graphics2D) bi.getGraphics();
g2.setFont(g2.getFont().deriveFont(sz));
g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, textHint);
g2.drawString("test", 100, 100);
}
public static void main(final String[] args) {
final GraphicsEnvironment ge =
GraphicsEnvironment.getLocalGraphicsEnvironment();
final GraphicsDevice gd = ge.getDefaultScreenDevice();
final GraphicsConfiguration gc = gd.getDefaultConfiguration();
final VolatileImage vi =
gc.createCompatibleVolatileImage(SIZE, SIZE, TRANSLUCENT);
final BufferedImage bi = makeUnmanagedBI(gc, TRANSLUCENT);
final int expected = bi.getRGB(2, 2);
int attempt = 0;
BufferedImage snapshot;
while (true) {
if (++attempt > 10) {
throw new RuntimeException("Too many attempts: " + attempt);
}
vi.validate(gc);
final Graphics2D g2d = vi.createGraphics();
g2d.setComposite(AlphaComposite.Src);
g2d.scale(2, 2);
g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BICUBIC);
g2d.drawImage(bi, 0, 0, null);
g2d.dispose();
snapshot = vi.getSnapshot();
if (vi.contentsLost()) {
continue;
}
break;
}
final int actual = snapshot.getRGB(2, 2);
if (actual != expected) {
System.err.println("Actual: " + Integer.toHexString(actual));
System.err.println("Expected: " + Integer.toHexString(expected));
throw new RuntimeException("Test failed");
}
}
@Override
public void paint(Graphics g, JComponent slider2) {
if (slider2 != slider)
throw new RuntimeException(
"only use this UI on the GradientSlider it was constructed with");
Graphics2D g2 = (Graphics2D) g;
int w = slider.getWidth();
int h = slider.getHeight();
if (slider.isOpaque()) {
g.setColor(slider.getBackground());
g.fillRect(0, 0, w, h);
}
if (slider2.hasFocus()) {
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
paintFocus(g2);
}
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_OFF);
paintTrack(g2);
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
paintThumbs(g2);
}
private void drawIcons(final Graphics2D g2d) {
if (!cardIcons.isEmpty()) {
final int BORDER_WIDTH = 2;
final BasicStroke BORDER_STROKE = new BasicStroke(BORDER_WIDTH);
final Stroke defaultStroke = g2d.getStroke();
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
// draw icons
int y = 10;
int x = 0;
final int ICON_WIDTH = 36;
final int ICON_HEIGHT = 32;
final int CORNER_ARC = 16;
final GradientPaint PAINT_COLOR = new GradientPaint(0, 0, GRADIENT_FROM_COLOR, ICON_WIDTH, 0, GRADIENT_TO_COLOR);
iconShapes.clear();
for (CardIcon cardIcon : cardIcons) {
// icon bounds should be relative to CardPopupPanel.
final Rectangle2D iconShapeRect = new Rectangle2D.Double((double)x, (double)y, (double)ICON_WIDTH, 32d);
iconShapes.add(iconShapeRect);
//
final Rectangle rect = new Rectangle(x, y, ICON_WIDTH, ICON_HEIGHT);
g2d.setPaint(PAINT_COLOR);
g2d.fillRoundRect(rect.x, rect.y, rect.width, rect.height, CORNER_ARC, CORNER_ARC);
g2d.setPaint(Color.BLACK);
g2d.setStroke(BORDER_STROKE);
g2d.drawRoundRect(rect.x, rect.y, rect.width, rect.height, CORNER_ARC, CORNER_ARC);
g2d.setStroke(defaultStroke);
//
final ImageIcon icon = cardIcon.getIcon();
final int iconOffsetX = (ICON_WIDTH / 2) - (icon.getIconWidth() / 2);
final int iconOffsetY = 16 - (icon.getIconHeight() / 2);
icon.paintIcon(this, g2d, x + iconOffsetX, y + iconOffsetY);
y += ICON_HEIGHT + 1;
}
}
}