Java tutorial
/* * Copyright (C) 2014 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.android.annotations.VisibleForTesting; import com.android.tools.idea.configurations.OverlayContainer; import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.awt.*; import java.util.ArrayList; import java.util.Collection; import java.util.List; /** * The {@link IncludeOverlay} class renders masks to <b>partially</b> hide everything outside * an included file's own content. This overlay is in use when you are editing an included * file shown within a different file's context (e.g. "Show In > other"). * <p> * TODO: Instead of masking out the entire viewport, consider only masking out the root * layout, and leaving the system bars alone? One problem with that approach is that * we may be rendering the action bar from the outer layout, which is really system UI * that should be grayed out. Perhaps we can consider combining the root bounds with the * bottom bounds of the root layout? We also need to handle the case where the surrounding * layout does not fill up the full height of the available screen (e.g. its layout_height * is wrap_content). */ public class IncludeOverlay extends Overlay { /** Mask transparency - 0 is transparent, 255 is opaque */ private static final int MASK_TRANSPARENCY = 160; private final OverlayContainer myContainer; /** * Constructs an {@link IncludeOverlay} tied to the given result. * * @param container The {@link OverlayContainer} containing this overlay */ public IncludeOverlay(@NotNull OverlayContainer container) { myContainer = container; } @Override public void paint(@Nullable Component component, @NotNull Graphics2D gc, int deltaX, int deltaY) { RenderedViewHierarchy viewHierarchy = myContainer.getViewHierarchy(); if (viewHierarchy == null) { return; } List<RenderedView> includedRoots = viewHierarchy.getIncludedRoots(); if (includedRoots == null || includedRoots.size() == 0 || component == null) { // We don't support multiple included children yet. When that works, // this code should use a BSP tree to figure out which regions to paint // to leave holes in the mask. return; } //noinspection UseJBColor gc.setColor(Color.GRAY); Composite prevComposite = gc.getComposite(); gc.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, MASK_TRANSPARENCY / 255.0f)); Shape prevClip = gc.getClip(); Shape clip = setScreenClip(myContainer, component, gc, deltaX, deltaY); Collection<Rectangle> masks = computeMasks(component, includedRoots); for (Rectangle r : masks) { gc.fillRect(r.x + deltaX, r.y + deltaY, r.width, r.height); } gc.setComposite(prevComposite); if (clip != null) { gc.setClip(prevClip); } } /** Computes the set of rectangles we should paint to cover everything up <b>except</b> for * the included root bounds. The coordinates will be in the coordinate system of the given * component. */ protected Collection<Rectangle> computeMasks(Component component, List<RenderedView> includedRoots) { Dimension fullImageSize = myContainer.getFullImageSize(); Rectangle whole = new Rectangle(0, 0, fullImageSize.width, fullImageSize.height); whole = myContainer.fromModel(component, whole); List<Rectangle> includedBounds = Lists.newArrayListWithExpectedSize(includedRoots.size()); for (RenderedView view : includedRoots) { includedBounds.add(myContainer.fromModel(component, view.getBounds())); } return subtractRectangles(whole, includedBounds); } /** * Given a Rectangle, remove holes from it (specified as a collection of Rectangles) such * that the result is a list of rectangles that cover everything that is not a hole. * * @param rectangle the rectangle to subtract from * @param holes the holes to subtract from the rectangle * @return a list of sub rectangles that remain after subtracting out the given list of holes */ @VisibleForTesting static Collection<Rectangle> subtractRectangles(Rectangle rectangle, Collection<Rectangle> holes) { List<Rectangle> result = new ArrayList<Rectangle>(); result.add(rectangle); for (Rectangle hole : holes) { List<Rectangle> tempResult = new ArrayList<Rectangle>(); for (Rectangle r : result) { if (hole.intersects(r)) { // Clip the hole to fit the rectangle bounds Rectangle h = hole.intersection(r); // Split the rectangle // Above (includes the NW and NE corners) if (h.y > r.y) { tempResult.add(new Rectangle(r.x, r.y, r.width, h.y - r.y)); } // Left (not including corners) if (h.x > r.x) { tempResult.add(new Rectangle(r.x, h.y, h.x - r.x, h.height)); } int hx2 = h.x + h.width; int hy2 = h.y + h.height; int rx2 = r.x + r.width; int ry2 = r.y + r.height; // Below (includes the SW and SE corners) if (hy2 < ry2) { tempResult.add(new Rectangle(r.x, hy2, r.width, ry2 - hy2)); } // Right (not including corners) if (hx2 < rx2) { tempResult.add(new Rectangle(hx2, h.y, rx2 - hx2, h.height)); } } else { tempResult.add(r); } } result = tempResult; } return result; } }