1 /* 2 * Copyright (c) 2006, 2018, 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 26 package java.awt; 27 28 import java.awt.MultipleGradientPaint.CycleMethod; 29 import java.awt.MultipleGradientPaint.ColorSpaceType; 30 import java.awt.color.ColorSpace; 31 import java.awt.geom.AffineTransform; 32 import java.awt.geom.NoninvertibleTransformException; 33 import java.awt.geom.Rectangle2D; 34 import java.awt.image.ColorModel; 35 import java.awt.image.DataBuffer; 36 import java.awt.image.DataBufferInt; 37 import java.awt.image.DirectColorModel; 38 import java.awt.image.Raster; 39 import java.awt.image.SinglePixelPackedSampleModel; 40 import java.awt.image.WritableRaster; 41 import java.lang.ref.SoftReference; 42 import java.lang.ref.WeakReference; 43 import java.util.Arrays; 44 45 /** 46 * This is the superclass for all PaintContexts which use a multiple color 47 * gradient to fill in their raster. It provides the actual color 48 * interpolation functionality. Subclasses only have to deal with using 49 * the gradient to fill pixels in a raster. 50 * 51 * @author Nicholas Talian, Vincent Hardy, Jim Graham, Jerry Evans 52 */ 53 abstract class MultipleGradientPaintContext implements PaintContext { 54 55 /** 56 * The PaintContext's ColorModel. This is ARGB if colors are not all 57 * opaque, otherwise it is RGB. 58 */ 59 protected ColorModel model; 60 61 /** Color model used if gradient colors are all opaque. */ 62 private static ColorModel xrgbmodel = 63 new DirectColorModel(24, 0x00ff0000, 0x0000ff00, 0x000000ff); 64 65 /** The cached ColorModel. */ 66 protected static ColorModel cachedModel; 67 68 /** The cached raster, which is reusable among instances. */ 69 protected static WeakReference<Raster> cached; 70 71 /** Raster is reused whenever possible. */ 72 protected Raster saved; 73 74 /** The method to use when painting out of the gradient bounds. */ 75 protected CycleMethod cycleMethod; 76 77 /** The ColorSpace in which to perform the interpolation */ 78 protected ColorSpaceType colorSpace; 79 80 /** Elements of the inverse transform matrix. */ 81 protected float a00, a01, a10, a11, a02, a12; 82 83 /** 84 * This boolean specifies whether we are in simple lookup mode, where an 85 * input value between 0 and 1 may be used to directly index into a single 86 * array of gradient colors. If this boolean value is false, then we have 87 * to use a 2-step process where we have to determine which gradient array 88 * we fall into, then determine the index into that array. 89 */ 90 protected boolean isSimpleLookup; 91 92 /** 93 * Size of gradients array for scaling the 0-1 index when looking up 94 * colors the fast way. 95 */ 96 protected int fastGradientArraySize; 97 98 /** 99 * Array which contains the interpolated color values for each interval, 100 * used by calculateSingleArrayGradient(). It is protected for possible 101 * direct access by subclasses. 102 */ 103 protected int[] gradient; 104 105 /** 106 * Array of gradient arrays, one array for each interval. Used by 107 * calculateMultipleArrayGradient(). 108 */ 109 private int[][] gradients; 110 111 /** Normalized intervals array. */ 112 private float[] normalizedIntervals; 113 114 /** Fractions array. */ 115 private float[] fractions; 116 117 /** Used to determine if gradient colors are all opaque. */ 118 private int transparencyTest; 119 120 /** Color space conversion lookup tables. */ 121 private static final int[] SRGBtoLinearRGB = new int[256]; 122 private static final int[] LinearRGBtoSRGB = new int[256]; 123 124 static { 125 // build the tables 126 for (int k = 0; k < 256; k++) { 127 SRGBtoLinearRGB[k] = convertSRGBtoLinearRGB(k); 128 LinearRGBtoSRGB[k] = convertLinearRGBtoSRGB(k); 129 } 130 } 131 132 /** 133 * Constant number of max colors between any 2 arbitrary colors. 134 * Used for creating and indexing gradients arrays. 135 */ 136 protected static final int GRADIENT_SIZE = 256; 137 protected static final int GRADIENT_SIZE_INDEX = GRADIENT_SIZE -1; 138 139 /** 140 * Maximum length of the fast single-array. If the estimated array size 141 * is greater than this, switch over to the slow lookup method. 142 * No particular reason for choosing this number, but it seems to provide 143 * satisfactory performance for the common case (fast lookup). 144 */ 145 private static final int MAX_GRADIENT_ARRAY_SIZE = 5000; 146 147 /** 148 * Constructor for MultipleGradientPaintContext superclass. 149 */ MultipleGradientPaintContext(MultipleGradientPaint mgp, ColorModel cm, Rectangle deviceBounds, Rectangle2D userBounds, AffineTransform t, RenderingHints hints, float[] fractions, Color[] colors, CycleMethod cycleMethod, ColorSpaceType colorSpace)150 protected MultipleGradientPaintContext(MultipleGradientPaint mgp, 151 ColorModel cm, 152 Rectangle deviceBounds, 153 Rectangle2D userBounds, 154 AffineTransform t, 155 RenderingHints hints, 156 float[] fractions, 157 Color[] colors, 158 CycleMethod cycleMethod, 159 ColorSpaceType colorSpace) 160 { 161 if (deviceBounds == null) { 162 throw new NullPointerException("Device bounds cannot be null"); 163 } 164 165 if (userBounds == null) { 166 throw new NullPointerException("User bounds cannot be null"); 167 } 168 169 if (t == null) { 170 throw new NullPointerException("Transform cannot be null"); 171 } 172 173 if (hints == null) { 174 throw new NullPointerException("RenderingHints cannot be null"); 175 } 176 177 // The inverse transform is needed to go from device to user space. 178 // Get all the components of the inverse transform matrix. 179 AffineTransform tInv; 180 try { 181 // the following assumes that the caller has copied the incoming 182 // transform and is not concerned about it being modified 183 t.invert(); 184 tInv = t; 185 } catch (NoninvertibleTransformException e) { 186 // just use identity transform in this case; better to show 187 // (incorrect) results than to throw an exception and/or no-op 188 tInv = new AffineTransform(); 189 } 190 double[] m = new double[6]; 191 tInv.getMatrix(m); 192 a00 = (float)m[0]; 193 a10 = (float)m[1]; 194 a01 = (float)m[2]; 195 a11 = (float)m[3]; 196 a02 = (float)m[4]; 197 a12 = (float)m[5]; 198 199 // copy some flags 200 this.cycleMethod = cycleMethod; 201 this.colorSpace = colorSpace; 202 203 // we can avoid copying this array since we do not modify its values 204 this.fractions = fractions; 205 206 // note that only one of these values can ever be non-null (we either 207 // store the fast gradient array or the slow one, but never both 208 // at the same time) 209 int[] gradient = 210 (mgp.gradient != null) ? mgp.gradient.get() : null; 211 int[][] gradients = 212 (mgp.gradients != null) ? mgp.gradients.get() : null; 213 214 if (gradient == null && gradients == null) { 215 // we need to (re)create the appropriate values 216 calculateLookupData(colors); 217 218 // now cache the calculated values in the 219 // MultipleGradientPaint instance for future use 220 mgp.model = this.model; 221 mgp.normalizedIntervals = this.normalizedIntervals; 222 mgp.isSimpleLookup = this.isSimpleLookup; 223 if (isSimpleLookup) { 224 // only cache the fast array 225 mgp.fastGradientArraySize = this.fastGradientArraySize; 226 mgp.gradient = new SoftReference<int[]>(this.gradient); 227 } else { 228 // only cache the slow array 229 mgp.gradients = new SoftReference<int[][]>(this.gradients); 230 } 231 } else { 232 // use the values cached in the MultipleGradientPaint instance 233 this.model = mgp.model; 234 this.normalizedIntervals = mgp.normalizedIntervals; 235 this.isSimpleLookup = mgp.isSimpleLookup; 236 this.gradient = gradient; 237 this.fastGradientArraySize = mgp.fastGradientArraySize; 238 this.gradients = gradients; 239 } 240 } 241 242 /** 243 * This function is the meat of this class. It calculates an array of 244 * gradient colors based on an array of fractions and color values at 245 * those fractions. 246 */ calculateLookupData(Color[] colors)247 private void calculateLookupData(Color[] colors) { 248 Color[] normalizedColors; 249 if (colorSpace == ColorSpaceType.LINEAR_RGB) { 250 // create a new colors array 251 normalizedColors = new Color[colors.length]; 252 // convert the colors using the lookup table 253 for (int i = 0; i < colors.length; i++) { 254 int argb = colors[i].getRGB(); 255 int a = argb >>> 24; 256 int r = SRGBtoLinearRGB[(argb >> 16) & 0xff]; 257 int g = SRGBtoLinearRGB[(argb >> 8) & 0xff]; 258 int b = SRGBtoLinearRGB[(argb ) & 0xff]; 259 normalizedColors[i] = new Color(r, g, b, a); 260 } 261 } else { 262 // we can just use this array by reference since we do not 263 // modify its values in the case of SRGB 264 normalizedColors = colors; 265 } 266 267 // this will store the intervals (distances) between gradient stops 268 normalizedIntervals = new float[fractions.length-1]; 269 270 // convert from fractions into intervals 271 for (int i = 0; i < normalizedIntervals.length; i++) { 272 // interval distance is equal to the difference in positions 273 normalizedIntervals[i] = this.fractions[i+1] - this.fractions[i]; 274 } 275 276 // initialize to be fully opaque for ANDing with colors 277 transparencyTest = 0xff000000; 278 279 // array of interpolation arrays 280 gradients = new int[normalizedIntervals.length][]; 281 282 // find smallest interval 283 float Imin = 1; 284 for (int i = 0; i < normalizedIntervals.length; i++) { 285 Imin = (Imin > normalizedIntervals[i]) ? 286 normalizedIntervals[i] : Imin; 287 } 288 289 // Estimate the size of the entire gradients array. 290 // This is to prevent a tiny interval from causing the size of array 291 // to explode. If the estimated size is too large, break to using 292 // separate arrays for each interval, and using an indexing scheme at 293 // look-up time. 294 int estimatedSize = 0; 295 for (int i = 0; i < normalizedIntervals.length; i++) { 296 estimatedSize += (normalizedIntervals[i]/Imin) * GRADIENT_SIZE; 297 } 298 299 if (estimatedSize > MAX_GRADIENT_ARRAY_SIZE) { 300 // slow method 301 calculateMultipleArrayGradient(normalizedColors); 302 } else { 303 // fast method 304 calculateSingleArrayGradient(normalizedColors, Imin); 305 } 306 307 // use the most "economical" model 308 if ((transparencyTest >>> 24) == 0xff) { 309 model = xrgbmodel; 310 } else { 311 model = ColorModel.getRGBdefault(); 312 } 313 } 314 315 /** 316 * FAST LOOKUP METHOD 317 * 318 * This method calculates the gradient color values and places them in a 319 * single int array, gradient[]. It does this by allocating space for 320 * each interval based on its size relative to the smallest interval in 321 * the array. The smallest interval is allocated 255 interpolated values 322 * (the maximum number of unique in-between colors in a 24 bit color 323 * system), and all other intervals are allocated 324 * size = (255 * the ratio of their size to the smallest interval). 325 * 326 * This scheme expedites a speedy retrieval because the colors are 327 * distributed along the array according to their user-specified 328 * distribution. All that is needed is a relative index from 0 to 1. 329 * 330 * The only problem with this method is that the possibility exists for 331 * the array size to balloon in the case where there is a 332 * disproportionately small gradient interval. In this case the other 333 * intervals will be allocated huge space, but much of that data is 334 * redundant. We thus need to use the space conserving scheme below. 335 * 336 * @param Imin the size of the smallest interval 337 */ calculateSingleArrayGradient(Color[] colors, float Imin)338 private void calculateSingleArrayGradient(Color[] colors, float Imin) { 339 // set the flag so we know later it is a simple (fast) lookup 340 isSimpleLookup = true; 341 342 // 2 colors to interpolate 343 int rgb1, rgb2; 344 345 //the eventual size of the single array 346 int gradientsTot = 1; 347 348 // for every interval (transition between 2 colors) 349 for (int i = 0; i < gradients.length; i++) { 350 // create an array whose size is based on the ratio to the 351 // smallest interval 352 int nGradients = (int)((normalizedIntervals[i]/Imin)*255f); 353 gradientsTot += nGradients; 354 gradients[i] = new int[nGradients]; 355 356 // the 2 colors (keyframes) to interpolate between 357 rgb1 = colors[i].getRGB(); 358 rgb2 = colors[i+1].getRGB(); 359 360 // fill this array with the colors in between rgb1 and rgb2 361 interpolate(rgb1, rgb2, gradients[i]); 362 363 // if the colors are opaque, transparency should still 364 // be 0xff000000 365 transparencyTest &= rgb1; 366 transparencyTest &= rgb2; 367 } 368 369 // put all gradients in a single array 370 gradient = new int[gradientsTot]; 371 int curOffset = 0; 372 for (int i = 0; i < gradients.length; i++){ 373 System.arraycopy(gradients[i], 0, gradient, 374 curOffset, gradients[i].length); 375 curOffset += gradients[i].length; 376 } 377 gradient[gradient.length-1] = colors[colors.length-1].getRGB(); 378 379 // if interpolation occurred in Linear RGB space, convert the 380 // gradients back to sRGB using the lookup table 381 if (colorSpace == ColorSpaceType.LINEAR_RGB) { 382 for (int i = 0; i < gradient.length; i++) { 383 gradient[i] = convertEntireColorLinearRGBtoSRGB(gradient[i]); 384 } 385 } 386 387 fastGradientArraySize = gradient.length - 1; 388 } 389 390 /** 391 * SLOW LOOKUP METHOD 392 * 393 * This method calculates the gradient color values for each interval and 394 * places each into its own 255 size array. The arrays are stored in 395 * gradients[][]. (255 is used because this is the maximum number of 396 * unique colors between 2 arbitrary colors in a 24 bit color system.) 397 * 398 * This method uses the minimum amount of space (only 255 * number of 399 * intervals), but it aggravates the lookup procedure, because now we 400 * have to find out which interval to select, then calculate the index 401 * within that interval. This causes a significant performance hit, 402 * because it requires this calculation be done for every point in 403 * the rendering loop. 404 * 405 * For those of you who are interested, this is a classic example of the 406 * time-space tradeoff. 407 */ calculateMultipleArrayGradient(Color[] colors)408 private void calculateMultipleArrayGradient(Color[] colors) { 409 // set the flag so we know later it is a non-simple lookup 410 isSimpleLookup = false; 411 412 // 2 colors to interpolate 413 int rgb1, rgb2; 414 415 // for every interval (transition between 2 colors) 416 for (int i = 0; i < gradients.length; i++){ 417 // create an array of the maximum theoretical size for 418 // each interval 419 gradients[i] = new int[GRADIENT_SIZE]; 420 421 // get the 2 colors 422 rgb1 = colors[i].getRGB(); 423 rgb2 = colors[i+1].getRGB(); 424 425 // fill this array with the colors in between rgb1 and rgb2 426 interpolate(rgb1, rgb2, gradients[i]); 427 428 // if the colors are opaque, transparency should still 429 // be 0xff000000 430 transparencyTest &= rgb1; 431 transparencyTest &= rgb2; 432 } 433 434 // if interpolation occurred in Linear RGB space, convert the 435 // gradients back to SRGB using the lookup table 436 if (colorSpace == ColorSpaceType.LINEAR_RGB) { 437 for (int j = 0; j < gradients.length; j++) { 438 for (int i = 0; i < gradients[j].length; i++) { 439 gradients[j][i] = 440 convertEntireColorLinearRGBtoSRGB(gradients[j][i]); 441 } 442 } 443 } 444 } 445 446 /** 447 * Yet another helper function. This one linearly interpolates between 448 * 2 colors, filling up the output array. 449 * 450 * @param rgb1 the start color 451 * @param rgb2 the end color 452 * @param output the output array of colors; must not be null 453 */ interpolate(int rgb1, int rgb2, int[] output)454 private void interpolate(int rgb1, int rgb2, int[] output) { 455 // color components 456 int a1, r1, g1, b1, da, dr, dg, db; 457 458 // step between interpolated values 459 float stepSize = 1.0f / output.length; 460 461 // extract color components from packed integer 462 a1 = (rgb1 >> 24) & 0xff; 463 r1 = (rgb1 >> 16) & 0xff; 464 g1 = (rgb1 >> 8) & 0xff; 465 b1 = (rgb1 ) & 0xff; 466 467 // calculate the total change in alpha, red, green, blue 468 da = ((rgb2 >> 24) & 0xff) - a1; 469 dr = ((rgb2 >> 16) & 0xff) - r1; 470 dg = ((rgb2 >> 8) & 0xff) - g1; 471 db = ((rgb2 ) & 0xff) - b1; 472 473 // for each step in the interval calculate the in-between color by 474 // multiplying the normalized current position by the total color 475 // change (0.5 is added to prevent truncation round-off error) 476 for (int i = 0; i < output.length; i++) { 477 output[i] = 478 (((int) ((a1 + i * da * stepSize) + 0.5) << 24)) | 479 (((int) ((r1 + i * dr * stepSize) + 0.5) << 16)) | 480 (((int) ((g1 + i * dg * stepSize) + 0.5) << 8)) | 481 (((int) ((b1 + i * db * stepSize) + 0.5) )); 482 } 483 } 484 485 /** 486 * Yet another helper function. This one extracts the color components 487 * of an integer RGB triple, converts them from LinearRGB to SRGB, then 488 * recompacts them into an int. 489 */ convertEntireColorLinearRGBtoSRGB(int rgb)490 private int convertEntireColorLinearRGBtoSRGB(int rgb) { 491 // color components 492 int a1, r1, g1, b1; 493 494 // extract red, green, blue components 495 a1 = (rgb >> 24) & 0xff; 496 r1 = (rgb >> 16) & 0xff; 497 g1 = (rgb >> 8) & 0xff; 498 b1 = (rgb ) & 0xff; 499 500 // use the lookup table 501 r1 = LinearRGBtoSRGB[r1]; 502 g1 = LinearRGBtoSRGB[g1]; 503 b1 = LinearRGBtoSRGB[b1]; 504 505 // re-compact the components 506 return ((a1 << 24) | 507 (r1 << 16) | 508 (g1 << 8) | 509 (b1 )); 510 } 511 512 /** 513 * Helper function to index into the gradients array. This is necessary 514 * because each interval has an array of colors with uniform size 255. 515 * However, the color intervals are not necessarily of uniform length, so 516 * a conversion is required. 517 * 518 * @param position the unmanipulated position, which will be mapped 519 * into the range 0 to 1 520 * @return integer color to display 521 */ indexIntoGradientsArrays(float position)522 protected final int indexIntoGradientsArrays(float position) { 523 // first, manipulate position value depending on the cycle method 524 if (cycleMethod == CycleMethod.NO_CYCLE) { 525 if (position > 1) { 526 // upper bound is 1 527 position = 1; 528 } else if (position < 0) { 529 // lower bound is 0 530 position = 0; 531 } 532 } else if (cycleMethod == CycleMethod.REPEAT) { 533 // get the fractional part 534 // (modulo behavior discards integer component) 535 position = position - (int)position; 536 537 //position should now be between -1 and 1 538 if (position < 0) { 539 // force it to be in the range 0-1 540 position = position + 1; 541 } 542 } else { // cycleMethod == CycleMethod.REFLECT 543 if (position < 0) { 544 // take absolute value 545 position = -position; 546 } 547 548 // get the integer part 549 int part = (int)position; 550 551 // get the fractional part 552 position = position - part; 553 554 if ((part & 1) == 1) { 555 // integer part is odd, get reflected color instead 556 position = 1 - position; 557 } 558 } 559 560 // now, get the color based on this 0-1 position... 561 562 if (isSimpleLookup) { 563 // easy to compute: just scale index by array size 564 return gradient[(int)(position * fastGradientArraySize)]; 565 } else { 566 // more complicated computation, to save space 567 568 // for all the gradient interval arrays 569 for (int i = 0; i < gradients.length; i++) { 570 if (position < fractions[i+1]) { 571 // this is the array we want 572 float delta = position - fractions[i]; 573 574 // this is the interval we want 575 int index = (int)((delta / normalizedIntervals[i]) 576 * (GRADIENT_SIZE_INDEX)); 577 578 return gradients[i][index]; 579 } 580 } 581 } 582 583 return gradients[gradients.length - 1][GRADIENT_SIZE_INDEX]; 584 } 585 586 /** 587 * Helper function to convert a color component in sRGB space to linear 588 * RGB space. Used to build a static lookup table. 589 */ convertSRGBtoLinearRGB(int color)590 private static int convertSRGBtoLinearRGB(int color) { 591 float input, output; 592 593 input = color / 255.0f; 594 if (input <= 0.04045f) { 595 output = input / 12.92f; 596 } else { 597 output = (float)Math.pow((input + 0.055) / 1.055, 2.4); 598 } 599 600 return Math.round(output * 255.0f); 601 } 602 603 /** 604 * Helper function to convert a color component in linear RGB space to 605 * SRGB space. Used to build a static lookup table. 606 */ convertLinearRGBtoSRGB(int color)607 private static int convertLinearRGBtoSRGB(int color) { 608 float input, output; 609 610 input = color/255.0f; 611 if (input <= 0.0031308) { 612 output = input * 12.92f; 613 } else { 614 output = (1.055f * 615 ((float) Math.pow(input, (1.0 / 2.4)))) - 0.055f; 616 } 617 618 return Math.round(output * 255.0f); 619 } 620 621 /** 622 * {@inheritDoc} 623 */ getRaster(int x, int y, int w, int h)624 public final Raster getRaster(int x, int y, int w, int h) { 625 // If working raster is big enough, reuse it. Otherwise, 626 // build a large enough new one. 627 Raster raster = saved; 628 if (raster == null || 629 raster.getWidth() < w || raster.getHeight() < h) 630 { 631 raster = getCachedRaster(model, w, h); 632 saved = raster; 633 } 634 635 // Access raster internal int array. Because we use a DirectColorModel, 636 // we know the DataBuffer is of type DataBufferInt and the SampleModel 637 // is SinglePixelPackedSampleModel. 638 // Adjust for initial offset in DataBuffer and also for the scanline 639 // stride. 640 // These calls make the DataBuffer non-acceleratable, but the 641 // Raster is never Stable long enough to accelerate anyway... 642 DataBufferInt rasterDB = (DataBufferInt)raster.getDataBuffer(); 643 int[] pixels = rasterDB.getData(0); 644 int off = rasterDB.getOffset(); 645 int scanlineStride = ((SinglePixelPackedSampleModel) 646 raster.getSampleModel()).getScanlineStride(); 647 int adjust = scanlineStride - w; 648 649 fillRaster(pixels, off, adjust, x, y, w, h); // delegate to subclass 650 651 return raster; 652 } 653 fillRaster(int[] pixels, int off, int adjust, int x, int y, int w, int h)654 protected abstract void fillRaster(int[] pixels, int off, int adjust, 655 int x, int y, int w, int h); 656 657 658 /** 659 * Took this cacheRaster code from GradientPaint. It appears to recycle 660 * rasters for use by any other instance, as long as they are sufficiently 661 * large. 662 */ getCachedRaster(ColorModel cm, int w, int h)663 private static synchronized Raster getCachedRaster(ColorModel cm, 664 int w, int h) 665 { 666 if (cm == cachedModel) { 667 if (cached != null) { 668 Raster ras = cached.get(); 669 if (ras != null && 670 ras.getWidth() >= w && 671 ras.getHeight() >= h) 672 { 673 cached = null; 674 return ras; 675 } 676 } 677 } 678 return cm.createCompatibleWritableRaster(w, h); 679 } 680 681 /** 682 * Took this cacheRaster code from GradientPaint. It appears to recycle 683 * rasters for use by any other instance, as long as they are sufficiently 684 * large. 685 */ putCachedRaster(ColorModel cm, Raster ras)686 private static synchronized void putCachedRaster(ColorModel cm, 687 Raster ras) 688 { 689 if (cached != null) { 690 Raster cras = cached.get(); 691 if (cras != null) { 692 int cw = cras.getWidth(); 693 int ch = cras.getHeight(); 694 int iw = ras.getWidth(); 695 int ih = ras.getHeight(); 696 if (cw >= iw && ch >= ih) { 697 return; 698 } 699 if (cw * ch >= iw * ih) { 700 return; 701 } 702 } 703 } 704 cachedModel = cm; 705 cached = new WeakReference<Raster>(ras); 706 } 707 708 /** 709 * {@inheritDoc} 710 */ dispose()711 public final void dispose() { 712 if (saved != null) { 713 putCachedRaster(model, saved); 714 saved = null; 715 } 716 } 717 718 /** 719 * {@inheritDoc} 720 */ getColorModel()721 public final ColorModel getColorModel() { 722 return model; 723 } 724 } 725