| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package com.android.tools.idea.rendering; |
| |
| import com.intellij.util.ui.UIUtil; |
| import org.jetbrains.annotations.NotNull; |
| |
| import java.awt.*; |
| import java.awt.image.BufferedImage; |
| import java.awt.image.DataBufferInt; |
| |
| public class ShadowPainter { |
| |
| /** |
| * Adds a drop shadow to a semi-transparent image (of an arbitrary shape) and returns it as a new image. |
| * This method attempts to mimic the same visual characteristics as the rectangular shadow painting |
| * methods in this class, {@link #createRectangularDropShadow(java.awt.image.BufferedImage)} and |
| * {@link #createSmallRectangularDropShadow(java.awt.image.BufferedImage)}. |
| * |
| * @param source the source image |
| * @param shadowSize the size of the shadow, normally {@link #SHADOW_SIZE or {@link #SMALL_SHADOW_SIZE}} |
| * @return a new image with the shadow painted in |
| */ |
| @NotNull |
| public static BufferedImage createDropShadow(BufferedImage source, int shadowSize) { |
| shadowSize /= 2; // make shadow size have the same meaning as in the other shadow paint methods in this class |
| |
| return createDropShadow(source, shadowSize, 0.7f, 0); |
| } |
| |
| /** |
| * Creates a drop shadow of a given image and returns a new image which shows the |
| * input image on top of its drop shadow. |
| * <p> |
| * <b>NOTE: If the shape is rectangular and opaque, consider using |
| * {@link #drawRectangleShadow(java.awt.Graphics, int, int, int, int)} instead.</b> |
| * |
| * @param source the source image to be shadowed |
| * @param shadowSize the size of the shadow in pixels |
| * @param shadowOpacity the opacity of the shadow, with 0=transparent and 1=opaque |
| * @param shadowRgb the RGB int to use for the shadow color |
| * @return a new image with the source image on top of its shadow |
| */ |
| @SuppressWarnings({"AssignmentToForLoopParameter", "UnnecessaryLocalVariable", // Imported code |
| "SuspiciousNameCombination", "UnusedAssignment"}) |
| public static BufferedImage createDropShadow(BufferedImage source, int shadowSize, |
| float shadowOpacity, int shadowRgb) { |
| |
| // This code is based on |
| // http://www.jroller.com/gfx/entry/non_rectangular_shadow |
| |
| BufferedImage image; |
| int width = source.getWidth(); |
| int height = source.getHeight(); |
| boolean isRetina = ImageUtils.isRetinaImage(source); |
| if (isRetina && UIUtil.isAppleRetina()) { |
| // This shadow painting code doesn't work right with the Apple JDK 6 Retina support. |
| // Since this code isn't used very frequently, just skip the drop shadows for now |
| return source; |
| } |
| if (isRetina) { |
| image = ImageUtils.createDipImage(width + SHADOW_SIZE, height + SHADOW_SIZE, BufferedImage.TYPE_INT_ARGB); |
| } else { |
| //noinspection UndesirableClassUsage |
| image = new BufferedImage(width + SHADOW_SIZE, height + SHADOW_SIZE, BufferedImage.TYPE_INT_ARGB); |
| } |
| |
| Graphics2D g2 = image.createGraphics(); |
| //noinspection ConstantConditions |
| UIUtil.drawImage(g2, source, shadowSize, shadowSize, null); |
| |
| int dstWidth = image.getWidth(); |
| int dstHeight = image.getHeight(); |
| |
| int left = (shadowSize - 1) >> 1; |
| int right = shadowSize - left; |
| int xStart = left; |
| int xStop = dstWidth - right; |
| int yStart = left; |
| int yStop = dstHeight - right; |
| |
| shadowRgb &= 0x00FFFFFF; |
| |
| int[] aHistory = new int[shadowSize]; |
| int historyIdx = 0; |
| |
| int aSum; |
| |
| int[] dataBuffer = ((DataBufferInt) image.getRaster().getDataBuffer()).getData(); |
| int lastPixelOffset = right * dstWidth; |
| float sumDivider = shadowOpacity / shadowSize; |
| |
| // horizontal pass |
| for (int y = 0, bufferOffset = 0; y < dstHeight; y++, bufferOffset = y * dstWidth) { |
| aSum = 0; |
| historyIdx = 0; |
| for (int x = 0; x < shadowSize; x++, bufferOffset++) { |
| int a = dataBuffer[bufferOffset] >>> 24; |
| aHistory[x] = a; |
| aSum += a; |
| } |
| |
| bufferOffset -= right; |
| |
| for (int x = xStart; x < xStop; x++, bufferOffset++) { |
| int a = (int) (aSum * sumDivider); |
| dataBuffer[bufferOffset] = a << 24 | shadowRgb; |
| |
| // subtract the oldest pixel from the sum |
| aSum -= aHistory[historyIdx]; |
| |
| // get the latest pixel |
| a = dataBuffer[bufferOffset + right] >>> 24; |
| aHistory[historyIdx] = a; |
| aSum += a; |
| |
| if (++historyIdx >= shadowSize) { |
| historyIdx -= shadowSize; |
| } |
| } |
| } |
| // vertical pass |
| for (int x = 0, bufferOffset = 0; x < dstWidth; x++, bufferOffset = x) { |
| aSum = 0; |
| historyIdx = 0; |
| for (int y = 0; y < shadowSize; y++, bufferOffset += dstWidth) { |
| int a = dataBuffer[bufferOffset] >>> 24; |
| aHistory[y] = a; |
| aSum += a; |
| } |
| |
| bufferOffset -= lastPixelOffset; |
| |
| for (int y = yStart; y < yStop; y++, bufferOffset += dstWidth) { |
| int a = (int) (aSum * sumDivider); |
| dataBuffer[bufferOffset] = a << 24 | shadowRgb; |
| |
| // subtract the oldest pixel from the sum |
| aSum -= aHistory[historyIdx]; |
| |
| // get the latest pixel |
| a = dataBuffer[bufferOffset + lastPixelOffset] >>> 24; |
| aHistory[historyIdx] = a; |
| aSum += a; |
| |
| if (++historyIdx >= shadowSize) { |
| historyIdx -= shadowSize; |
| } |
| } |
| } |
| |
| //noinspection ConstantConditions |
| UIUtil.drawImage(g2, source, null, 0, 0); |
| g2.dispose(); |
| |
| return image; |
| } |
| |
| /** |
| * Draws a rectangular drop shadow (of size {@link #SHADOW_SIZE} by |
| * {@link #SHADOW_SIZE} around the given source and returns a new image with |
| * both combined |
| * |
| * @param source the source image |
| * @return the source image with a drop shadow on the bottom and right |
| */ |
| public static BufferedImage createRectangularDropShadow(BufferedImage source) { |
| int type = source.getType(); |
| if (type == BufferedImage.TYPE_CUSTOM) { |
| type = BufferedImage.TYPE_INT_ARGB; |
| } |
| |
| int width = source.getWidth(); |
| int height = source.getHeight(); |
| BufferedImage image; |
| if (ImageUtils.isRetinaImage(source)) { |
| image = ImageUtils.createDipImage(width + SHADOW_SIZE, height + SHADOW_SIZE, type); |
| } else { |
| //noinspection UndesirableClassUsage |
| image = new BufferedImage(width + SHADOW_SIZE, height + SHADOW_SIZE, type); |
| } |
| Graphics g = image.getGraphics(); |
| //noinspection ConstantConditions |
| UIUtil.drawImage(g, source, 0, 0, null); |
| drawRectangleShadow(image, 0, 0, width, height); |
| g.dispose(); |
| |
| return image; |
| } |
| |
| /** |
| * Draws a small rectangular drop shadow (of size {@link #SMALL_SHADOW_SIZE} by |
| * {@link #SMALL_SHADOW_SIZE} around the given source and returns a new image with |
| * both combined |
| * |
| * @param source the source image |
| * @return the source image with a drop shadow on the bottom and right |
| */ |
| public static BufferedImage createSmallRectangularDropShadow(BufferedImage source) { |
| int type = source.getType(); |
| if (type == BufferedImage.TYPE_CUSTOM) { |
| type = BufferedImage.TYPE_INT_ARGB; |
| } |
| |
| int width = source.getWidth(); |
| int height = source.getHeight(); |
| |
| BufferedImage image; |
| if (ImageUtils.isRetinaImage(source)) { |
| image = ImageUtils.createDipImage(width + SMALL_SHADOW_SIZE, height + SMALL_SHADOW_SIZE, type); |
| } else { |
| //noinspection UndesirableClassUsage |
| image = new BufferedImage(width + SMALL_SHADOW_SIZE, height + SMALL_SHADOW_SIZE, type); |
| } |
| |
| Graphics g = image.getGraphics(); |
| //noinspection ConstantConditions |
| UIUtil.drawImage(g, source, 0, 0, null); |
| drawSmallRectangleShadow(image, 0, 0, width, height); |
| g.dispose(); |
| |
| return image; |
| } |
| |
| /** |
| * Draws a drop shadow for the given rectangle into the given context. It |
| * will not draw anything if the rectangle is smaller than a minimum |
| * determined by the assets used to draw the shadow graphics. |
| * The size of the shadow is {@link #SHADOW_SIZE}. |
| * |
| * @param image the image to draw the shadow into |
| * @param x the left coordinate of the left hand side of the rectangle |
| * @param y the top coordinate of the top of the rectangle |
| * @param width the width of the rectangle |
| * @param height the height of the rectangle |
| */ |
| public static void drawRectangleShadow(BufferedImage image, |
| int x, int y, int width, int height) { |
| Graphics gc = image.getGraphics(); |
| try { |
| drawRectangleShadow(gc, x, y, width, height); |
| } finally { |
| gc.dispose(); |
| } |
| } |
| |
| /** |
| * Draws a small drop shadow for the given rectangle into the given context. It |
| * will not draw anything if the rectangle is smaller than a minimum |
| * determined by the assets used to draw the shadow graphics. |
| * The size of the shadow is {@link #SMALL_SHADOW_SIZE}. |
| * |
| * @param image the image to draw the shadow into |
| * @param x the left coordinate of the left hand side of the rectangle |
| * @param y the top coordinate of the top of the rectangle |
| * @param width the width of the rectangle |
| * @param height the height of the rectangle |
| */ |
| public static void drawSmallRectangleShadow(BufferedImage image, |
| int x, int y, int width, int height) { |
| Graphics gc = image.getGraphics(); |
| try { |
| drawSmallRectangleShadow(gc, x, y, width, height); |
| } finally { |
| gc.dispose(); |
| } |
| } |
| |
| /** |
| * The width and height of the drop shadow painted by |
| * {@link #drawRectangleShadow(Graphics, int, int, int, int)} |
| */ |
| public static final int SHADOW_SIZE = 20; // DO NOT EDIT. This corresponds to bitmap graphics |
| |
| /** |
| * The width and height of the drop shadow painted by |
| * {@link #drawSmallRectangleShadow(Graphics, int, int, int, int)} |
| */ |
| public static final int SMALL_SHADOW_SIZE = 10; // DO NOT EDIT. Corresponds to bitmap graphics |
| |
| /** |
| * Draws a drop shadow for the given rectangle into the given context. It |
| * will not draw anything if the rectangle is smaller than a minimum |
| * determined by the assets used to draw the shadow graphics. |
| * |
| * @param gc the graphics context to draw into |
| * @param x the left coordinate of the left hand side of the rectangle |
| * @param y the top coordinate of the top of the rectangle |
| * @param width the width of the rectangle |
| * @param height the height of the rectangle |
| */ |
| @SuppressWarnings("ConstantConditions") |
| public static void drawRectangleShadow(Graphics gc, int x, int y, int width, int height) { |
| assert ShadowBottomLeft != null; |
| assert ShadowBottomRight.getWidth(null) == SHADOW_SIZE; |
| assert ShadowBottomRight.getHeight(null) == SHADOW_SIZE; |
| |
| int blWidth = ShadowBottomLeft.getWidth(null); |
| int trHeight = ShadowTopRight.getHeight(null); |
| if (width < blWidth) { |
| return; |
| } |
| if (height < trHeight) { |
| return; |
| } |
| |
| UIUtil.drawImage(gc, ShadowBottomLeft, x, y + height, null); |
| UIUtil.drawImage(gc, ShadowBottomRight, x + width, y + height, null); |
| UIUtil.drawImage(gc, ShadowTopRight, x + width, y, null); |
| ImageUtils.drawDipImage(gc, ShadowBottom, x + ShadowBottomLeft.getWidth(null), y + height, x + width, |
| y + height + ShadowBottom.getHeight(null), 0, 0, ShadowBottom.getWidth(null), ShadowBottom.getHeight(null), |
| null); |
| ImageUtils.drawDipImage(gc, ShadowRight, x + width, y + ShadowTopRight.getHeight(null), x + width + ShadowRight.getWidth(null), |
| y + height, 0, 0, ShadowRight.getWidth(null), ShadowRight.getHeight(null), null); |
| } |
| |
| /** |
| * Draws a small drop shadow for the given rectangle into the given context. It |
| * will not draw anything if the rectangle is smaller than a minimum |
| * determined by the assets used to draw the shadow graphics. |
| * <p> |
| * |
| * @param gc the graphics context to draw into |
| * @param x the left coordinate of the left hand side of the rectangle |
| * @param y the top coordinate of the top of the rectangle |
| * @param width the width of the rectangle |
| * @param height the height of the rectangle |
| */ |
| @SuppressWarnings("ConstantConditions") |
| public static void drawSmallRectangleShadow(Graphics gc, int x, int y, int width, int height) { |
| assert Shadow2BottomLeft != null; |
| assert Shadow2TopRight != null; |
| assert Shadow2BottomRight.getWidth(null) == SMALL_SHADOW_SIZE; |
| assert Shadow2BottomRight.getHeight(null) == SMALL_SHADOW_SIZE; |
| |
| int blWidth = Shadow2BottomLeft.getWidth(null); |
| int trHeight = Shadow2TopRight.getHeight(null); |
| if (width < blWidth) { |
| return; |
| } |
| if (height < trHeight) { |
| return; |
| } |
| |
| UIUtil.drawImage(gc, Shadow2BottomLeft, x, y + height, null); |
| UIUtil.drawImage(gc, Shadow2BottomRight, x + width, y + height, null); |
| UIUtil.drawImage(gc, Shadow2TopRight, x + width, y, null); |
| ImageUtils.drawDipImage(gc, Shadow2Bottom, x + Shadow2BottomLeft.getWidth(null), y + height, x + width, |
| y + height + Shadow2Bottom.getHeight(null), 0, 0, Shadow2Bottom.getWidth(null), Shadow2Bottom.getHeight(null), |
| null); |
| ImageUtils.drawDipImage(gc, Shadow2Right, x + width, y + Shadow2TopRight.getHeight(null), x + width + Shadow2Right.getWidth(null), |
| y + height, 0, 0, Shadow2Right.getWidth(null), Shadow2Right.getHeight(null), null); |
| } |
| |
| // Shadow graphics. This was generated by creating a drop shadow in |
| // Gimp, using the parameters x offset=10, y offset=10, blur radius=10, |
| // (for the small drop shadows x offset=10, y offset=10, blur radius=10) |
| // color=black, and opacity=51. These values attempt to make a shadow |
| // that is legible both for dark and light themes, on top of the |
| // canvas background (rgb(150,150,150). Darker shadows would tend to |
| // blend into the foreground for a dark holo screen, and lighter shadows |
| // would be hard to spot on the canvas background. If you make adjustments, |
| // make sure to check the shadow with both dark and light themes. |
| // |
| // After making the graphics, I cut out the top right, bottom left |
| // and bottom right corners as 20x20 images, and these are reproduced by |
| // painting them in the corresponding places in the target graphics context. |
| // I then grabbed a single horizontal gradient line from the middle of the |
| // right edge,and a single vertical gradient line from the bottom. These |
| // are then painted scaled/stretched in the target to fill the gaps between |
| // the three corner images. |
| // |
| // Filenames: bl=bottom left, b=bottom, br=bottom right, r=right, tr=top right |
| |
| // Normal Drop Shadow |
| private static final Image ShadowBottom = ImageUtils.loadIcon("/icons/shadow-b.png"); |
| private static final Image ShadowBottomLeft = ImageUtils.loadIcon("/icons/shadow-bl.png"); |
| private static final Image ShadowBottomRight = ImageUtils.loadIcon("/icons/shadow-br.png"); |
| private static final Image ShadowRight = ImageUtils.loadIcon("/icons/shadow-r.png"); |
| private static final Image ShadowTopRight = ImageUtils.loadIcon("/icons/shadow-tr.png"); |
| |
| // Small Drop Shadow |
| private static final Image Shadow2Bottom = ImageUtils.loadIcon("/icons/shadow2-b.png"); |
| private static final Image Shadow2BottomLeft = ImageUtils.loadIcon("/icons/shadow2-bl.png"); |
| private static final Image Shadow2BottomRight = ImageUtils.loadIcon("/icons/shadow2-br.png"); |
| private static final Image Shadow2Right = ImageUtils.loadIcon("/icons/shadow2-r.png"); |
| private static final Image Shadow2TopRight = ImageUtils.loadIcon("/icons/shadow2-tr.png"); |
| } |