1 /*
   2  * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package javax.swing.plaf.nimbus;
  26 
  27 import java.awt.*;
  28 import java.awt.image.*;
  29 import java.lang.reflect.Method;
  30 import javax.swing.*;
  31 import javax.swing.plaf.UIResource;
  32 import javax.swing.Painter;
  33 import java.awt.print.PrinterGraphics;
  34 import sun.reflect.misc.MethodUtil;
  35 
  36 /**
  37  * Convenient base class for defining Painter instances for rendering a
  38  * region or component in Nimbus.
  39  *
  40  * @author Jasper Potts
  41  * @author Richard Bair
  42  */
  43 public abstract class AbstractRegionPainter implements Painter<JComponent> {
  44     /**
  45      * PaintContext, which holds a lot of the state needed for cache hinting and x/y value decoding
  46      * The data contained within the context is typically only computed once and reused over
  47      * multiple paint calls, whereas the other values (w, h, f, leftWidth, etc) are recomputed
  48      * for each call to paint.
  49      *
  50      * This field is retrieved from subclasses on each paint operation. It is up
  51      * to the subclass to compute and cache the PaintContext over multiple calls.
  52      */
  53     private PaintContext ctx;
  54     /**
  55      * The scaling factor. Recomputed on each call to paint.
  56      */
  57     private float f;
  58     /*
  59       Various metrics used for decoding x/y values based on the canvas size
  60       and stretching insets.
  61 
  62       On each call to paint, we first ask the subclass for the PaintContext.
  63       From the context we get the canvas size and stretching insets, and whether
  64       the algorithm should be "inverted", meaning the center section remains
  65       a fixed size and the other sections scale.
  66 
  67       We then use these values to compute a series of metrics (listed below)
  68       which are used to decode points in a specific axis (x or y).
  69 
  70       The leftWidth represents the distance from the left edge of the region
  71       to the first stretching inset, after accounting for any scaling factor
  72       (such as DPI scaling). The centerWidth is the distance between the leftWidth
  73       and the rightWidth. The rightWidth is the distance from the right edge,
  74       to the right inset (after scaling has been applied).
  75 
  76       The same logic goes for topHeight, centerHeight, and bottomHeight.
  77 
  78       The leftScale represents the proportion of the width taken by the left section.
  79       The same logic is applied to the other scales.
  80 
  81       The various widths/heights are used to decode control points. The
  82       various scales are used to decode bezier handles (or anchors).
  83     */
  84     /**
  85      * The width of the left section. Recomputed on each call to paint.
  86      */
  87     private float leftWidth;
  88     /**
  89      * The height of the top section. Recomputed on each call to paint.
  90      */
  91     private float topHeight;
  92     /**
  93      * The width of the center section. Recomputed on each call to paint.
  94      */
  95     private float centerWidth;
  96     /**
  97      * The height of the center section. Recomputed on each call to paint.
  98      */
  99     private float centerHeight;
 100     /**
 101      * The width of the right section. Recomputed on each call to paint.
 102      */
 103     private float rightWidth;
 104     /**
 105      * The height of the bottom section. Recomputed on each call to paint.
 106      */
 107     private float bottomHeight;
 108     /**
 109      * The scaling factor to use for the left section. Recomputed on each call to paint.
 110      */
 111     private float leftScale;
 112     /**
 113      * The scaling factor to use for the top section. Recomputed on each call to paint.
 114      */
 115     private float topScale;
 116     /**
 117      * The scaling factor to use for the center section, in the horizontal
 118      * direction. Recomputed on each call to paint.
 119      */
 120     private float centerHScale;
 121     /**
 122      * The scaling factor to use for the center section, in the vertical
 123      * direction. Recomputed on each call to paint.
 124      */
 125     private float centerVScale;
 126     /**
 127      * The scaling factor to use for the right section. Recomputed on each call to paint.
 128      */
 129     private float rightScale;
 130     /**
 131      * The scaling factor to use for the bottom section. Recomputed on each call to paint.
 132      */
 133     private float bottomScale;
 134 
 135     /**
 136      * Create a new AbstractRegionPainter
 137      */
 138     protected AbstractRegionPainter() { }
 139 
 140     /**
 141      * {@inheritDoc}
 142      */
 143     @Override
 144     public final void paint(Graphics2D g, JComponent c, int w, int h) {
 145         //don't render if the width/height are too small
 146         if (w <= 0 || h <=0) return;
 147 
 148         Object[] extendedCacheKeys = getExtendedCacheKeys(c);
 149         ctx = getPaintContext();
 150         PaintContext.CacheMode cacheMode = ctx == null ? PaintContext.CacheMode.NO_CACHING : ctx.cacheMode;
 151         if (cacheMode == PaintContext.CacheMode.NO_CACHING ||
 152                 !ImageCache.getInstance().isImageCachable(w, h) ||
 153                 g instanceof PrinterGraphics) {
 154             // no caching so paint directly
 155             paint0(g, c, w, h, extendedCacheKeys);
 156         } else if (cacheMode == PaintContext.CacheMode.FIXED_SIZES) {
 157             paintWithFixedSizeCaching(g, c, w, h, extendedCacheKeys);
 158         } else {
 159             // 9 Square caching
 160             paintWith9SquareCaching(g, ctx, c, w, h, extendedCacheKeys);
 161         }
 162     }
 163 
 164     /**
 165      * Get any extra attributes which the painter implementation would like
 166      * to include in the image cache lookups. This is checked for every call
 167      * of the paint(g, c, w, h) method.
 168      *
 169      * @param c The component on the current paint call
 170      * @return Array of extra objects to be included in the cache key
 171      */
 172     protected Object[] getExtendedCacheKeys(JComponent c) {
 173         return null;
 174     }
 175 
 176     /**
 177      * <p>Gets the PaintContext for this painting operation. This method is called on every
 178      * paint, and so should be fast and produce no garbage. The PaintContext contains
 179      * information such as cache hints. It also contains data necessary for decoding
 180      * points at runtime, such as the stretching insets, the canvas size at which the
 181      * encoded points were defined, and whether the stretching insets are inverted.</p>
 182      *
 183      * <p> This method allows for subclasses to package the painting of different states
 184      * with possibly different canvas sizes, etc, into one AbstractRegionPainter implementation.</p>
 185      *
 186      * @return a PaintContext associated with this paint operation.
 187      */
 188     protected abstract PaintContext getPaintContext();
 189 
 190     /**
 191      * <p>Configures the given Graphics2D. Often, rendering hints or compositing rules are
 192      * applied to a Graphics2D object prior to painting, which should affect all of the
 193      * subsequent painting operations. This method provides a convenient hook for configuring
 194      * the Graphics object prior to rendering, regardless of whether the render operation is
 195      * performed to an intermediate buffer or directly to the display.</p>
 196      *
 197      * @param g The Graphics2D object to configure. Will not be null.
 198      */
 199     protected void configureGraphics(Graphics2D g) {
 200         g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 201     }
 202 
 203     /**
 204      * Actually performs the painting operation. Subclasses must implement this method.
 205      * The graphics object passed may represent the actual surface being rendered to,
 206      * or it may be an intermediate buffer. It has also been pre-translated. Simply render
 207      * the component as if it were located at 0, 0 and had a width of <code>width</code>
 208      * and a height of <code>height</code>. For performance reasons, you may want to read
 209      * the clip from the Graphics2D object and only render within that space.
 210      *
 211      * @param g The Graphics2D surface to paint to
 212      * @param c The JComponent related to the drawing event. For example, if the
 213      *          region being rendered is Button, then <code>c</code> will be a
 214      *          JButton. If the region being drawn is ScrollBarSlider, then the
 215      *          component will be JScrollBar. This value may be null.
 216      * @param width The width of the region to paint. Note that in the case of
 217      *              painting the foreground, this value may differ from c.getWidth().
 218      * @param height The height of the region to paint. Note that in the case of
 219      *               painting the foreground, this value may differ from c.getHeight().
 220      * @param extendedCacheKeys The result of the call to getExtendedCacheKeys()
 221      */
 222     protected abstract void doPaint(Graphics2D g, JComponent c, int width,
 223                                     int height, Object[] extendedCacheKeys);
 224 
 225     /**
 226      * Decodes and returns a float value representing the actual pixel location for
 227      * the given encoded X value.
 228      *
 229      * @param x an encoded x value (0...1, or 1...2, or 2...3)
 230      * @return the decoded x value
 231      * @throws IllegalArgumentException
 232      *      if {@code x < 0} or {@code x > 3}
 233      */
 234     protected final float decodeX(float x) {
 235         if (x >= 0 && x <= 1) {
 236             return x * leftWidth;
 237         } else if (x > 1 && x < 2) {
 238             return ((x-1) * centerWidth) + leftWidth;
 239         } else if (x >= 2 && x <= 3) {
 240             return ((x-2) * rightWidth) + leftWidth + centerWidth;
 241         } else {
 242             throw new IllegalArgumentException("Invalid x");
 243         }
 244     }
 245 
 246     /**
 247      * Decodes and returns a float value representing the actual pixel location for
 248      * the given encoded y value.
 249      *
 250      * @param y an encoded y value (0...1, or 1...2, or 2...3)
 251      * @return the decoded y value
 252      * @throws IllegalArgumentException
 253      *      if {@code y < 0} or {@code y > 3}
 254      */
 255     protected final float decodeY(float y) {
 256         if (y >= 0 && y <= 1) {
 257             return y * topHeight;
 258         } else if (y > 1 && y < 2) {
 259             return ((y-1) * centerHeight) + topHeight;
 260         } else if (y >= 2 && y <= 3) {
 261             return ((y-2) * bottomHeight) + topHeight + centerHeight;
 262         } else {
 263             throw new IllegalArgumentException("Invalid y");
 264         }
 265     }
 266 
 267     /**
 268      * Decodes and returns a float value representing the actual pixel location for
 269      * the anchor point given the encoded X value of the control point, and the offset
 270      * distance to the anchor from that control point.
 271      *
 272      * @param x an encoded x value of the bezier control point (0...1, or 1...2, or 2...3)
 273      * @param dx the offset distance to the anchor from the control point x
 274      * @return the decoded x location of the control point
 275      * @throws IllegalArgumentException
 276      *      if {@code x < 0} or {@code x > 3}
 277      */
 278     protected final float decodeAnchorX(float x, float dx) {
 279         if (x >= 0 && x <= 1) {
 280             return decodeX(x) + (dx * leftScale);
 281         } else if (x > 1 && x < 2) {
 282             return decodeX(x) + (dx * centerHScale);
 283         } else if (x >= 2 && x <= 3) {
 284             return decodeX(x) + (dx * rightScale);
 285         } else {
 286             throw new IllegalArgumentException("Invalid x");
 287         }
 288     }
 289 
 290     /**
 291      * Decodes and returns a float value representing the actual pixel location for
 292      * the anchor point given the encoded Y value of the control point, and the offset
 293      * distance to the anchor from that control point.
 294      *
 295      * @param y an encoded y value of the bezier control point (0...1, or 1...2, or 2...3)
 296      * @param dy the offset distance to the anchor from the control point y
 297      * @return the decoded y position of the control point
 298      * @throws IllegalArgumentException
 299      *      if {@code y < 0} or {@code y > 3}
 300      */
 301     protected final float decodeAnchorY(float y, float dy) {
 302         if (y >= 0 && y <= 1) {
 303             return decodeY(y) + (dy * topScale);
 304         } else if (y > 1 && y < 2) {
 305             return decodeY(y) + (dy * centerVScale);
 306         } else if (y >= 2 && y <= 3) {
 307             return decodeY(y) + (dy * bottomScale);
 308         } else {
 309             throw new IllegalArgumentException("Invalid y");
 310         }
 311     }
 312 
 313     /**
 314      * Decodes and returns a color, which is derived from a base color in UI
 315      * defaults.
 316      *
 317      * @param key     A key corresponding to the value in the UI Defaults table
 318      *                of UIManager where the base color is defined
 319      * @param hOffset The hue offset used for derivation.
 320      * @param sOffset The saturation offset used for derivation.
 321      * @param bOffset The brightness offset used for derivation.
 322      * @param aOffset The alpha offset used for derivation. Between 0...255
 323      * @return The derived color, whose color value will change if the parent
 324      *         uiDefault color changes.
 325      */
 326     protected final Color decodeColor(String key, float hOffset, float sOffset,
 327                                       float bOffset, int aOffset) {
 328         if (UIManager.getLookAndFeel() instanceof NimbusLookAndFeel){
 329             NimbusLookAndFeel laf = (NimbusLookAndFeel) UIManager.getLookAndFeel();
 330             return laf.getDerivedColor(key, hOffset, sOffset, bOffset, aOffset, true);
 331         } else {
 332             // can not give a right answer as painter sould not be used outside
 333             // of nimbus laf but do the best we can
 334             return Color.getHSBColor(hOffset,sOffset,bOffset);
 335         }
 336     }
 337 
 338     /**
 339      * Decodes and returns a color, which is derived from a offset between two
 340      * other colors.
 341      *
 342      * @param color1   The first color
 343      * @param color2   The second color
 344      * @param midPoint The offset between color 1 and color 2, a value of 0.0 is
 345      *                 color 1 and 1.0 is color 2;
 346      * @return The derived color
 347      */
 348     protected final Color decodeColor(Color color1, Color color2,
 349                                       float midPoint) {
 350         return new Color(NimbusLookAndFeel.deriveARGB(color1, color2, midPoint));
 351     }
 352 
 353     /**
 354      * Given parameters for creating a LinearGradientPaint, this method will
 355      * create and return a linear gradient paint. One primary purpose for this
 356      * method is to avoid creating a LinearGradientPaint where the start and
 357      * end points are equal. In such a case, the end y point is slightly
 358      * increased to avoid the overlap.
 359      *
 360      * @param x1 x1
 361      * @param y1 y1
 362      * @param x2 x2
 363      * @param y2 y2
 364      * @param midpoints the midpoints
 365      * @param colors the colors
 366      * @return a valid LinearGradientPaint. This method never returns null.
 367      * @throws NullPointerException
 368      *      if {@code midpoints} array is null,
 369      *      or {@code colors} array is null,
 370      * @throws IllegalArgumentException
 371      *      if start and end points are the same points,
 372      *      or {@code midpoints.length != colors.length},
 373      *      or {@code colors} is less than 2 in size,
 374      *      or a {@code midpoints} value is less than 0.0 or greater than 1.0,
 375      *      or the {@code midpoints} are not provided in strictly increasing order
 376      */
 377     protected final LinearGradientPaint decodeGradient(float x1, float y1, float x2, float y2, float[] midpoints, Color[] colors) {
 378         if (x1 == x2 && y1 == y2) {
 379             y2 += .00001f;
 380         }
 381         return new LinearGradientPaint(x1, y1, x2, y2, midpoints, colors);
 382     }
 383 
 384     /**
 385      * Given parameters for creating a RadialGradientPaint, this method will
 386      * create and return a radial gradient paint. One primary purpose for this
 387      * method is to avoid creating a RadialGradientPaint where the radius
 388      * is non-positive. In such a case, the radius is just slightly
 389      * increased to avoid 0.
 390      *
 391      * @param x x-coordinate
 392      * @param y y-coordinate
 393      * @param r radius
 394      * @param midpoints the midpoints
 395      * @param colors the colors
 396      * @return a valid RadialGradientPaint. This method never returns null.
 397      * @throws NullPointerException
 398      *      if {@code midpoints} array is null,
 399      *      or {@code colors} array is null
 400      * @throws IllegalArgumentException
 401      *      if {@code r} is non-positive,
 402      *      or {@code midpoints.length != colors.length},
 403      *      or {@code colors} is less than 2 in size,
 404      *      or a {@code midpoints} value is less than 0.0 or greater than 1.0,
 405      *      or the {@code midpoints} are not provided in strictly increasing order
 406      */
 407     protected final RadialGradientPaint decodeRadialGradient(float x, float y, float r, float[] midpoints, Color[] colors) {
 408         if (r == 0f) {
 409             r = .00001f;
 410         }
 411         return new RadialGradientPaint(x, y, r, midpoints, colors);
 412     }
 413 
 414     /**
 415      * Get a color property from the given JComponent. First checks for a
 416      * <code>getXXX()</code> method and if that fails checks for a client
 417      * property with key <code>property</code>. If that still fails to return
 418      * a Color then <code>defaultColor</code> is returned.
 419      *
 420      * @param c The component to get the color property from
 421      * @param property The name of a bean style property or client property
 422      * @param defaultColor The color to return if no color was obtained from
 423      *        the component.
 424      * @param saturationOffset additively modifies the HSB saturation component
 425      * of the color returned (ignored if default color is returned).
 426      * @param brightnessOffset additively modifies the HSB brightness component
 427      * of the color returned (ignored if default color is returned).
 428      * @param alphaOffset additively modifies the ARGB alpha component of the
 429      * color returned (ignored if default color is returned).
 430      *
 431      * @return The color that was obtained from the component or defaultColor
 432      */
 433     protected final Color getComponentColor(JComponent c, String property,
 434                                             Color defaultColor,
 435                                             float saturationOffset,
 436                                             float brightnessOffset,
 437                                             int alphaOffset) {
 438         Color color = null;
 439         if (c != null) {
 440             // handle some special cases for performance
 441             if ("background".equals(property)) {
 442                 color = c.getBackground();
 443             } else if ("foreground".equals(property)) {
 444                 color = c.getForeground();
 445             } else if (c instanceof JList && "selectionForeground".equals(property)) {
 446                 color = ((JList) c).getSelectionForeground();
 447             } else if (c instanceof JList && "selectionBackground".equals(property)) {
 448                 color = ((JList) c).getSelectionBackground();
 449             } else if (c instanceof JTable && "selectionForeground".equals(property)) {
 450                 color = ((JTable) c).getSelectionForeground();
 451             } else if (c instanceof JTable && "selectionBackground".equals(property)) {
 452                 color = ((JTable) c).getSelectionBackground();
 453             } else {
 454                 String s = "get" + Character.toUpperCase(property.charAt(0)) + property.substring(1);
 455                 try {
 456                     Method method = MethodUtil.getMethod(c.getClass(), s, null);
 457                     color = (Color) MethodUtil.invoke(method, c, null);
 458                 } catch (Exception e) {
 459                     //don't do anything, it just didn't work, that's all.
 460                     //This could be a normal occurance if you use a property
 461                     //name referring to a key in clientProperties instead of
 462                     //a real property
 463                 }
 464                 if (color == null) {
 465                     Object value = c.getClientProperty(property);
 466                     if (value instanceof Color) {
 467                         color = (Color) value;
 468                     }
 469                 }
 470             }
 471         }
 472         // we return the defaultColor if the color found is null, or if
 473         // it is a UIResource. This is done because the color for the
 474         // ENABLED state is set on the component, but you don't want to use
 475         // that color for the over state. So we only respect the color
 476         // specified for the property if it was set by the user, as opposed
 477         // to set by us.
 478         if (color == null || color instanceof UIResource) {
 479             return defaultColor;
 480         } else if (saturationOffset != 0 || brightnessOffset != 0 || alphaOffset != 0) {
 481             float[] tmp = Color.RGBtoHSB(color.getRed(), color.getGreen(), color.getBlue(), null);
 482             tmp[1] = clamp(tmp[1] + saturationOffset);
 483             tmp[2] = clamp(tmp[2] + brightnessOffset);
 484             int alpha = clamp(color.getAlpha() + alphaOffset);
 485             return new Color((Color.HSBtoRGB(tmp[0], tmp[1], tmp[2]) & 0xFFFFFF) | (alpha <<24));
 486         } else {
 487             return color;
 488         }
 489     }
 490 
 491     /**
 492      * A class encapsulating state useful when painting. Generally, instances of this
 493      * class are created once, and reused for each paint request without modification.
 494      * This class contains values useful when hinting the cache engine, and when decoding
 495      * control points and bezier curve anchors.
 496      */
 497     protected static class PaintContext {
 498         protected static enum CacheMode {
 499             NO_CACHING, FIXED_SIZES, NINE_SQUARE_SCALE
 500         }
 501 
 502         private static Insets EMPTY_INSETS = new Insets(0, 0, 0, 0);
 503 
 504         private Insets stretchingInsets;
 505         private Dimension canvasSize;
 506         private boolean inverted;
 507         private CacheMode cacheMode;
 508         private double maxHorizontalScaleFactor;
 509         private double maxVerticalScaleFactor;
 510 
 511         private float a; // insets.left
 512         private float b; // canvasSize.width - insets.right
 513         private float c; // insets.top
 514         private float d; // canvasSize.height - insets.bottom;
 515         private float aPercent; // only used if inverted == true
 516         private float bPercent; // only used if inverted == true
 517         private float cPercent; // only used if inverted == true
 518         private float dPercent; // only used if inverted == true
 519 
 520         /**
 521          * Creates a new PaintContext which does not attempt to cache or scale any cached
 522          * images.
 523          *
 524          * @param insets The stretching insets. May be null. If null, then assumed to be 0, 0, 0, 0.
 525          * @param canvasSize The size of the canvas used when encoding the various x/y values. May be null.
 526          *                   If null, then it is assumed that there are no encoded values, and any calls
 527          *                   to one of the "decode" methods will return the passed in value.
 528          * @param inverted Whether to "invert" the meaning of the 9-square grid and stretching insets
 529          */
 530         public PaintContext(Insets insets, Dimension canvasSize, boolean inverted) {
 531             this(insets, canvasSize, inverted, null, 1, 1);
 532         }
 533 
 534         /**
 535          * Creates a new PaintContext.
 536          *
 537          * @param insets The stretching insets. May be null. If null, then assumed to be 0, 0, 0, 0.
 538          * @param canvasSize The size of the canvas used when encoding the various x/y values. May be null.
 539          *                   If null, then it is assumed that there are no encoded values, and any calls
 540          *                   to one of the "decode" methods will return the passed in value.
 541          * @param inverted Whether to "invert" the meaning of the 9-square grid and stretching insets
 542          * @param cacheMode A hint as to which caching mode to use. If null, then set to no caching.
 543          * @param maxH The maximum scale in the horizontal direction to use before punting and redrawing from scratch.
 544          *             For example, if maxH is 2, then we will attempt to scale any cached images up to 2x the canvas
 545          *             width before redrawing from scratch. Reasonable maxH values may improve painting performance.
 546          *             If set too high, then you may get poor looking graphics at higher zoom levels. Must be &gt;= 1.
 547          * @param maxV The maximum scale in the vertical direction to use before punting and redrawing from scratch.
 548          *             For example, if maxV is 2, then we will attempt to scale any cached images up to 2x the canvas
 549          *             height before redrawing from scratch. Reasonable maxV values may improve painting performance.
 550          *             If set too high, then you may get poor looking graphics at higher zoom levels. Must be &gt;= 1.
 551          */
 552         public PaintContext(Insets insets, Dimension canvasSize, boolean inverted,
 553                             CacheMode cacheMode, double maxH, double maxV) {
 554             if (maxH < 1 || maxH < 1) {
 555                 throw new IllegalArgumentException("Both maxH and maxV must be >= 1");
 556             }
 557 
 558             this.stretchingInsets = insets == null ? EMPTY_INSETS : insets;
 559             this.canvasSize = canvasSize;
 560             this.inverted = inverted;
 561             this.cacheMode = cacheMode == null ? CacheMode.NO_CACHING : cacheMode;
 562             this.maxHorizontalScaleFactor = maxH;
 563             this.maxVerticalScaleFactor = maxV;
 564 
 565             if (canvasSize != null) {
 566                 a = stretchingInsets.left;
 567                 b = canvasSize.width - stretchingInsets.right;
 568                 c = stretchingInsets.top;
 569                 d = canvasSize.height - stretchingInsets.bottom;
 570                 this.canvasSize = canvasSize;
 571                 this.inverted = inverted;
 572                 if (inverted) {
 573                     float available = canvasSize.width - (b - a);
 574                     aPercent = available > 0f ? a / available : 0f;
 575                     bPercent = available > 0f ? b / available : 0f;
 576                     available = canvasSize.height - (d - c);
 577                     cPercent = available > 0f ? c / available : 0f;
 578                     dPercent = available > 0f ? d / available : 0f;
 579                 }
 580             }
 581         }
 582     }
 583 
 584     //---------------------- private methods
 585 
 586     //initializes the class to prepare it for being able to decode points
 587     private void prepare(float w, float h) {
 588         //if no PaintContext has been specified, reset the values and bail
 589         //also bail if the canvasSize was not set (since decoding will not work)
 590         if (ctx == null || ctx.canvasSize == null) {
 591             f = 1f;
 592             leftWidth = centerWidth = rightWidth = 0f;
 593             topHeight = centerHeight = bottomHeight = 0f;
 594             leftScale = centerHScale = rightScale = 0f;
 595             topScale = centerVScale = bottomScale = 0f;
 596             return;
 597         }
 598 
 599         //calculate the scaling factor, and the sizes for the various 9-square sections
 600         Number scale = (Number)UIManager.get("scale");
 601         f = scale == null ? 1f : scale.floatValue();
 602 
 603         if (ctx.inverted) {
 604             centerWidth = (ctx.b - ctx.a) * f;
 605             float availableSpace = w - centerWidth;
 606             leftWidth = availableSpace * ctx.aPercent;
 607             rightWidth = availableSpace * ctx.bPercent;
 608             centerHeight = (ctx.d - ctx.c) * f;
 609             availableSpace = h - centerHeight;
 610             topHeight = availableSpace * ctx.cPercent;
 611             bottomHeight = availableSpace * ctx.dPercent;
 612         } else {
 613             leftWidth = ctx.a * f;
 614             rightWidth = (float)(ctx.canvasSize.getWidth() - ctx.b) * f;
 615             centerWidth = w - leftWidth - rightWidth;
 616             topHeight = ctx.c * f;
 617             bottomHeight = (float)(ctx.canvasSize.getHeight() - ctx.d) * f;
 618             centerHeight = h - topHeight - bottomHeight;
 619         }
 620 
 621         leftScale = ctx.a == 0f ? 0f : leftWidth / ctx.a;
 622         centerHScale = (ctx.b - ctx.a) == 0f ? 0f : centerWidth / (ctx.b - ctx.a);
 623         rightScale = (ctx.canvasSize.width - ctx.b) == 0f ? 0f : rightWidth / (ctx.canvasSize.width - ctx.b);
 624         topScale = ctx.c == 0f ? 0f : topHeight / ctx.c;
 625         centerVScale = (ctx.d - ctx.c) == 0f ? 0f : centerHeight / (ctx.d - ctx.c);
 626         bottomScale = (ctx.canvasSize.height - ctx.d) == 0f ? 0f : bottomHeight / (ctx.canvasSize.height - ctx.d);
 627     }
 628 
 629     private void paintWith9SquareCaching(Graphics2D g, PaintContext ctx,
 630                                          JComponent c, int w, int h,
 631                                          Object[] extendedCacheKeys) {
 632         // check if we can scale to the requested size
 633         Dimension canvas = ctx.canvasSize;
 634         Insets insets = ctx.stretchingInsets;
 635 
 636         if (w <= (canvas.width * ctx.maxHorizontalScaleFactor) && h <= (canvas.height * ctx.maxVerticalScaleFactor)) {
 637             // get image at canvas size
 638             VolatileImage img = getImage(g.getDeviceConfiguration(), c, canvas.width, canvas.height, extendedCacheKeys);
 639             if (img != null) {
 640                 // calculate dst inserts
 641                 // todo: destination inserts need to take into acount scale factor for high dpi. Note: You can use f for this, I think
 642                 Insets dstInsets;
 643                 if (ctx.inverted){
 644                     int leftRight = (w-(canvas.width-(insets.left+insets.right)))/2;
 645                     int topBottom = (h-(canvas.height-(insets.top+insets.bottom)))/2;
 646                     dstInsets = new Insets(topBottom,leftRight,topBottom,leftRight);
 647                 } else {
 648                     dstInsets = insets;
 649                 }
 650                 // paint 9 square scaled
 651                 Object oldScaleingHints = g.getRenderingHint(RenderingHints.KEY_INTERPOLATION);
 652                 g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,RenderingHints.VALUE_INTERPOLATION_BILINEAR);
 653                 ImageScalingHelper.paint(g, 0, 0, w, h, img, insets, dstInsets,
 654                         ImageScalingHelper.PaintType.PAINT9_STRETCH, ImageScalingHelper.PAINT_ALL);
 655                 g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
 656                     oldScaleingHints!=null?oldScaleingHints:RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
 657             } else {
 658                 // render directly
 659                 paint0(g, c, w, h, extendedCacheKeys);
 660             }
 661         } else {
 662             // paint directly
 663             paint0(g, c, w, h, extendedCacheKeys);
 664         }
 665     }
 666 
 667     private void paintWithFixedSizeCaching(Graphics2D g, JComponent c, int w,
 668                                            int h, Object[] extendedCacheKeys) {
 669         VolatileImage img = getImage(g.getDeviceConfiguration(), c, w, h, extendedCacheKeys);
 670         if (img != null) {
 671             //render cached image
 672             g.drawImage(img, 0, 0, null);
 673         } else {
 674             // render directly
 675             paint0(g, c, w, h, extendedCacheKeys);
 676         }
 677     }
 678 
 679     /** Gets the rendered image for this painter at the requested size, either from cache or create a new one */
 680     private VolatileImage getImage(GraphicsConfiguration config, JComponent c,
 681                                    int w, int h, Object[] extendedCacheKeys) {
 682         ImageCache imageCache = ImageCache.getInstance();
 683         //get the buffer for this component
 684         VolatileImage buffer = (VolatileImage) imageCache.getImage(config, w, h, this, extendedCacheKeys);
 685 
 686         int renderCounter = 0; //to avoid any potential, though unlikely, infinite loop
 687         do {
 688             //validate the buffer so we can check for surface loss
 689             int bufferStatus = VolatileImage.IMAGE_INCOMPATIBLE;
 690             if (buffer != null) {
 691                 bufferStatus = buffer.validate(config);
 692             }
 693 
 694             //If the buffer status is incompatible or restored, then we need to re-render to the volatile image
 695             if (bufferStatus == VolatileImage.IMAGE_INCOMPATIBLE || bufferStatus == VolatileImage.IMAGE_RESTORED) {
 696                 //if the buffer is null (hasn't been created), or isn't the right size, or has lost its contents,
 697                 //then recreate the buffer
 698                 if (buffer == null || buffer.getWidth() != w || buffer.getHeight() != h ||
 699                         bufferStatus == VolatileImage.IMAGE_INCOMPATIBLE) {
 700                     //clear any resources related to the old back buffer
 701                     if (buffer != null) {
 702                         buffer.flush();
 703                         buffer = null;
 704                     }
 705                     //recreate the buffer
 706                     buffer = config.createCompatibleVolatileImage(w, h,
 707                             Transparency.TRANSLUCENT);
 708                     // put in cache for future
 709                     imageCache.setImage(buffer, config, w, h, this, extendedCacheKeys);
 710                 }
 711                 //create the graphics context with which to paint to the buffer
 712                 Graphics2D bg = buffer.createGraphics();
 713                 //clear the background before configuring the graphics
 714                 bg.setComposite(AlphaComposite.Clear);
 715                 bg.fillRect(0, 0, w, h);
 716                 bg.setComposite(AlphaComposite.SrcOver);
 717                 configureGraphics(bg);
 718                 // paint the painter into buffer
 719                 paint0(bg, c, w, h, extendedCacheKeys);
 720                 //close buffer graphics
 721                 bg.dispose();
 722             }
 723         } while (buffer.contentsLost() && renderCounter++ < 3);
 724         // check if we failed
 725         if (renderCounter == 3) return null;
 726         // return image
 727         return buffer;
 728     }
 729 
 730     //convenience method which creates a temporary graphics object by creating a
 731     //clone of the passed in one, configuring it, drawing with it, disposing it.
 732     //These steps have to be taken to ensure that any hints set on the graphics
 733     //are removed subsequent to painting.
 734     private void paint0(Graphics2D g, JComponent c, int width, int height,
 735                         Object[] extendedCacheKeys) {
 736         prepare(width, height);
 737         g = (Graphics2D)g.create();
 738         configureGraphics(g);
 739         doPaint(g, c, width, height, extendedCacheKeys);
 740         g.dispose();
 741     }
 742 
 743     private float clamp(float value) {
 744         if (value < 0) {
 745             value = 0;
 746         } else if (value > 1) {
 747             value = 1;
 748         }
 749         return value;
 750     }
 751 
 752     private int clamp(int value) {
 753         if (value < 0) {
 754             value = 0;
 755         } else if (value > 255) {
 756             value = 255;
 757         }
 758         return value;
 759     }
 760 }