| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php |
| * |
| * 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.ide.eclipse.adt.internal.editors.layout.gle2; |
| |
| import static com.android.SdkConstants.ANDROID_STYLE_RESOURCE_PREFIX; |
| import static com.android.SdkConstants.PREFIX_RESOURCE_REF; |
| import static com.android.SdkConstants.STYLE_RESOURCE_PREFIX; |
| import static com.android.ide.eclipse.adt.internal.editors.layout.configuration.Configuration.MASK_RENDERING; |
| import static com.android.ide.eclipse.adt.internal.editors.layout.gle2.ImageUtils.SHADOW_SIZE; |
| import static com.android.ide.eclipse.adt.internal.editors.layout.gle2.ImageUtils.SMALL_SHADOW_SIZE; |
| import static com.android.ide.eclipse.adt.internal.editors.layout.gle2.RenderPreviewMode.DEFAULT; |
| import static com.android.ide.eclipse.adt.internal.editors.layout.gle2.RenderPreviewMode.INCLUDES; |
| |
| import com.android.annotations.NonNull; |
| import com.android.annotations.Nullable; |
| import com.android.ide.common.rendering.api.RenderSession; |
| import com.android.ide.common.rendering.api.ResourceValue; |
| import com.android.ide.common.rendering.api.Result; |
| import com.android.ide.common.rendering.api.Result.Status; |
| import com.android.ide.common.resources.ResourceFile; |
| import com.android.ide.common.resources.ResourceRepository; |
| import com.android.ide.common.resources.ResourceResolver; |
| import com.android.ide.common.resources.configuration.FolderConfiguration; |
| import com.android.ide.common.resources.configuration.ScreenOrientationQualifier; |
| import com.android.ide.eclipse.adt.AdtPlugin; |
| import com.android.ide.eclipse.adt.AdtUtils; |
| import com.android.ide.eclipse.adt.internal.editors.IconFactory; |
| import com.android.ide.eclipse.adt.internal.editors.descriptors.DocumentDescriptor; |
| import com.android.ide.eclipse.adt.internal.editors.layout.configuration.Configuration; |
| import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationChooser; |
| import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationClient; |
| import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationDescription; |
| import com.android.ide.eclipse.adt.internal.editors.layout.configuration.Locale; |
| import com.android.ide.eclipse.adt.internal.editors.layout.configuration.NestedConfiguration; |
| import com.android.ide.eclipse.adt.internal.editors.layout.configuration.VaryingConfiguration; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gle2.IncludeFinder.Reference; |
| import com.android.ide.eclipse.adt.internal.editors.uimodel.UiDocumentNode; |
| import com.android.ide.eclipse.adt.internal.resources.ResourceHelper; |
| import com.android.ide.eclipse.adt.internal.resources.manager.ProjectResources; |
| import com.android.ide.eclipse.adt.internal.resources.manager.ResourceManager; |
| import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; |
| import com.android.ide.eclipse.adt.internal.sdk.Sdk; |
| import com.android.ide.eclipse.adt.io.IFileWrapper; |
| import com.android.io.IAbstractFile; |
| import com.android.resources.Density; |
| import com.android.resources.ResourceType; |
| import com.android.resources.ScreenOrientation; |
| import com.android.sdklib.IAndroidTarget; |
| import com.android.sdklib.devices.Device; |
| import com.android.sdklib.devices.Screen; |
| import com.android.sdklib.devices.State; |
| import com.android.utils.SdkUtils; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.jobs.IJobChangeEvent; |
| import org.eclipse.core.runtime.jobs.IJobChangeListener; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.jface.dialogs.InputDialog; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.GC; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.ImageData; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.Region; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.ui.ISharedImages; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.progress.UIJob; |
| import org.w3c.dom.Document; |
| |
| import java.awt.Graphics2D; |
| import java.awt.image.BufferedImage; |
| import java.io.File; |
| import java.lang.ref.SoftReference; |
| import java.util.Comparator; |
| import java.util.Map; |
| |
| /** |
| * Represents a preview rendering of a given configuration |
| */ |
| public class RenderPreview implements IJobChangeListener { |
| /** Whether previews should use large shadows */ |
| static final boolean LARGE_SHADOWS = false; |
| |
| /** |
| * Still doesn't work; get exceptions from layoutlib: |
| * java.lang.IllegalStateException: After scene creation, #init() must be called |
| * at com.android.layoutlib.bridge.impl.RenderAction.acquire(RenderAction.java:151) |
| * <p> |
| * TODO: Investigate. |
| */ |
| private static final boolean RENDER_ASYNC = false; |
| |
| /** |
| * Height of the toolbar shown over a preview during hover. Needs to be |
| * large enough to accommodate icons below. |
| */ |
| private static final int HEADER_HEIGHT = 20; |
| |
| /** Whether to dump out rendering failures of the previews to the log */ |
| private static final boolean DUMP_RENDER_DIAGNOSTICS = false; |
| |
| /** Extra error checking in debug mode */ |
| private static final boolean DEBUG = false; |
| |
| private static final Image EDIT_ICON; |
| private static final Image ZOOM_IN_ICON; |
| private static final Image ZOOM_OUT_ICON; |
| private static final Image CLOSE_ICON; |
| private static final int EDIT_ICON_WIDTH; |
| private static final int ZOOM_IN_ICON_WIDTH; |
| private static final int ZOOM_OUT_ICON_WIDTH; |
| private static final int CLOSE_ICON_WIDTH; |
| static { |
| ISharedImages sharedImages = PlatformUI.getWorkbench().getSharedImages(); |
| IconFactory icons = IconFactory.getInstance(); |
| CLOSE_ICON = sharedImages.getImage(ISharedImages.IMG_ETOOL_DELETE); |
| EDIT_ICON = icons.getIcon("editPreview"); //$NON-NLS-1$ |
| ZOOM_IN_ICON = icons.getIcon("zoomplus"); //$NON-NLS-1$ |
| ZOOM_OUT_ICON = icons.getIcon("zoomminus"); //$NON-NLS-1$ |
| CLOSE_ICON_WIDTH = CLOSE_ICON.getImageData().width; |
| EDIT_ICON_WIDTH = EDIT_ICON.getImageData().width; |
| ZOOM_IN_ICON_WIDTH = ZOOM_IN_ICON.getImageData().width; |
| ZOOM_OUT_ICON_WIDTH = ZOOM_OUT_ICON.getImageData().width; |
| } |
| |
| /** The configuration being previewed */ |
| private @NonNull Configuration mConfiguration; |
| |
| /** Configuration to use if we have an alternate input to be rendered */ |
| private @NonNull Configuration mAlternateConfiguration; |
| |
| /** The associated manager */ |
| private final @NonNull RenderPreviewManager mManager; |
| private final @NonNull LayoutCanvas mCanvas; |
| |
| private @NonNull SoftReference<ResourceResolver> mResourceResolver = |
| new SoftReference<ResourceResolver>(null); |
| private @Nullable Job mJob; |
| private @Nullable Image mThumbnail; |
| private @Nullable String mDisplayName; |
| private int mWidth; |
| private int mHeight; |
| private int mX; |
| private int mY; |
| private int mTitleHeight; |
| private double mScale = 1.0; |
| private double mAspectRatio; |
| |
| /** If non null, points to a separate file containing the source */ |
| private @Nullable IFile mAlternateInput; |
| |
| /** If included within another layout, the name of that outer layout */ |
| private @Nullable Reference mIncludedWithin; |
| |
| /** Whether the mouse is actively hovering over this preview */ |
| private boolean mActive; |
| |
| /** |
| * Whether this preview cannot be rendered because of a model error - such |
| * as an invalid configuration, a missing resource, an error in the XML |
| * markup, etc. If non null, contains the error message (or a blank string |
| * if not known), and null if the render was successful. |
| */ |
| private String mError; |
| |
| /** Whether in the current layout, this preview is visible */ |
| private boolean mVisible; |
| |
| /** Whether the configuration has changed and needs to be refreshed the next time |
| * this preview made visible. This corresponds to the change flags in |
| * {@link ConfigurationClient}. */ |
| private int mDirty; |
| |
| /** |
| * Creates a new {@linkplain RenderPreview} |
| * |
| * @param manager the manager |
| * @param canvas canvas where preview is painted |
| * @param configuration the associated configuration |
| * @param width the initial width to use for the preview |
| * @param height the initial height to use for the preview |
| */ |
| private RenderPreview( |
| @NonNull RenderPreviewManager manager, |
| @NonNull LayoutCanvas canvas, |
| @NonNull Configuration configuration) { |
| mManager = manager; |
| mCanvas = canvas; |
| mConfiguration = configuration; |
| updateSize(); |
| |
| // Should only attempt to create configurations for fully configured devices |
| assert mConfiguration.getDevice() != null |
| && mConfiguration.getDeviceState() != null |
| && mConfiguration.getLocale() != null |
| && mConfiguration.getTarget() != null |
| && mConfiguration.getTheme() != null |
| && mConfiguration.getFullConfig() != null |
| && mConfiguration.getFullConfig().getScreenSizeQualifier() != null : |
| mConfiguration; |
| } |
| |
| /** |
| * Sets the configuration to use for this preview |
| * |
| * @param configuration the new configuration |
| */ |
| public void setConfiguration(@NonNull Configuration configuration) { |
| mConfiguration = configuration; |
| } |
| |
| /** |
| * Gets the scale being applied to the thumbnail |
| * |
| * @return the scale being applied to the thumbnail |
| */ |
| public double getScale() { |
| return mScale; |
| } |
| |
| /** |
| * Sets the scale to apply to the thumbnail |
| * |
| * @param scale the factor to scale the thumbnail picture by |
| */ |
| public void setScale(double scale) { |
| disposeThumbnail(); |
| mScale = scale; |
| } |
| |
| /** |
| * Returns the aspect ratio of this render preview |
| * |
| * @return the aspect ratio |
| */ |
| public double getAspectRatio() { |
| return mAspectRatio; |
| } |
| |
| /** |
| * Returns whether the preview is actively hovered |
| * |
| * @return whether the mouse is hovering over the preview |
| */ |
| public boolean isActive() { |
| return mActive; |
| } |
| |
| /** |
| * Sets whether the preview is actively hovered |
| * |
| * @param active if the mouse is hovering over the preview |
| */ |
| public void setActive(boolean active) { |
| mActive = active; |
| } |
| |
| /** |
| * Returns whether the preview is visible. Previews that are off |
| * screen are typically marked invisible during layout, which means we don't |
| * have to expend effort computing preview thumbnails etc |
| * |
| * @return true if the preview is visible |
| */ |
| public boolean isVisible() { |
| return mVisible; |
| } |
| |
| /** |
| * Returns whether this preview represents a forked layout |
| * |
| * @return true if this preview represents a separate file |
| */ |
| public boolean isForked() { |
| return mAlternateInput != null || mIncludedWithin != null; |
| } |
| |
| /** |
| * Returns the file to be used for this preview, or null if this is not a |
| * forked layout meaning that the file is the one used in the chooser |
| * |
| * @return the file or null for non-forked layouts |
| */ |
| @Nullable |
| public IFile getAlternateInput() { |
| if (mAlternateInput != null) { |
| return mAlternateInput; |
| } else if (mIncludedWithin != null) { |
| return mIncludedWithin.getFile(); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the area of this render preview, PRIOR to scaling |
| * |
| * @return the area (width times height without scaling) |
| */ |
| int getArea() { |
| return mWidth * mHeight; |
| } |
| |
| /** |
| * Sets whether the preview is visible. Previews that are off |
| * screen are typically marked invisible during layout, which means we don't |
| * have to expend effort computing preview thumbnails etc |
| * |
| * @param visible whether this preview is visible |
| */ |
| public void setVisible(boolean visible) { |
| if (visible != mVisible) { |
| mVisible = visible; |
| if (mVisible) { |
| if (mDirty != 0) { |
| // Just made the render preview visible: |
| configurationChanged(mDirty); // schedules render |
| } else { |
| updateForkStatus(); |
| mManager.scheduleRender(this); |
| } |
| } else { |
| dispose(); |
| } |
| } |
| } |
| |
| /** |
| * Sets the layout position relative to the top left corner of the preview |
| * area, in control coordinates |
| */ |
| void setPosition(int x, int y) { |
| mX = x; |
| mY = y; |
| } |
| |
| /** |
| * Gets the layout X position relative to the top left corner of the preview |
| * area, in control coordinates |
| */ |
| int getX() { |
| return mX; |
| } |
| |
| /** |
| * Gets the layout Y position relative to the top left corner of the preview |
| * area, in control coordinates |
| */ |
| int getY() { |
| return mY; |
| } |
| |
| /** Determine whether this configuration has a better match in a different layout file */ |
| private void updateForkStatus() { |
| ConfigurationChooser chooser = mManager.getChooser(); |
| FolderConfiguration config = mConfiguration.getFullConfig(); |
| if (mAlternateInput != null && chooser.isBestMatchFor(mAlternateInput, config)) { |
| return; |
| } |
| |
| mAlternateInput = null; |
| IFile editedFile = chooser.getEditedFile(); |
| if (editedFile != null) { |
| if (!chooser.isBestMatchFor(editedFile, config)) { |
| ProjectResources resources = chooser.getResources(); |
| if (resources != null) { |
| ResourceFile best = resources.getMatchingFile(editedFile.getName(), |
| ResourceType.LAYOUT, config); |
| if (best != null) { |
| IAbstractFile file = best.getFile(); |
| if (file instanceof IFileWrapper) { |
| mAlternateInput = ((IFileWrapper) file).getIFile(); |
| } else if (file instanceof File) { |
| mAlternateInput = AdtUtils.fileToIFile(((File) file)); |
| } |
| } |
| } |
| if (mAlternateInput != null) { |
| mAlternateConfiguration = Configuration.create(mConfiguration, |
| mAlternateInput); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Creates a new {@linkplain RenderPreview} |
| * |
| * @param manager the manager |
| * @param configuration the associated configuration |
| * @return a new configuration |
| */ |
| @NonNull |
| public static RenderPreview create( |
| @NonNull RenderPreviewManager manager, |
| @NonNull Configuration configuration) { |
| LayoutCanvas canvas = manager.getCanvas(); |
| return new RenderPreview(manager, canvas, configuration); |
| } |
| |
| /** |
| * Throws away this preview: cancels any pending rendering jobs and disposes |
| * of image resources etc |
| */ |
| public void dispose() { |
| disposeThumbnail(); |
| |
| if (mJob != null) { |
| mJob.cancel(); |
| mJob = null; |
| } |
| } |
| |
| /** Disposes the thumbnail rendering. */ |
| void disposeThumbnail() { |
| if (mThumbnail != null) { |
| mThumbnail.dispose(); |
| mThumbnail = null; |
| } |
| } |
| |
| /** |
| * Returns the display name of this preview |
| * |
| * @return the name of the preview |
| */ |
| @NonNull |
| public String getDisplayName() { |
| if (mDisplayName == null) { |
| String displayName = getConfiguration().getDisplayName(); |
| if (displayName == null) { |
| // No display name: this must be the configuration used by default |
| // for the view which is originally displayed (before adding thumbnails), |
| // and you've switched away to something else; now we need to display a name |
| // for this original configuration. For now, just call it "Original" |
| return "Original"; |
| } |
| |
| return displayName; |
| } |
| |
| return mDisplayName; |
| } |
| |
| /** |
| * Sets the display name of this preview. By default, the display name is |
| * the display name of the configuration, but it can be overridden by calling |
| * this setter (which only sets the preview name, without editing the configuration.) |
| * |
| * @param displayName the new display name |
| */ |
| public void setDisplayName(@NonNull String displayName) { |
| mDisplayName = displayName; |
| } |
| |
| /** |
| * Sets an inclusion context to use for this layout, if any. This will render |
| * the configuration preview as the outer layout with the current layout |
| * embedded within. |
| * |
| * @param includedWithin a reference to a layout which includes this one |
| */ |
| public void setIncludedWithin(Reference includedWithin) { |
| mIncludedWithin = includedWithin; |
| } |
| |
| /** |
| * Request a new render after the given delay |
| * |
| * @param delay the delay to wait before starting the render job |
| */ |
| public void render(long delay) { |
| Job job = mJob; |
| if (job != null) { |
| job.cancel(); |
| } |
| if (RENDER_ASYNC) { |
| job = new AsyncRenderJob(); |
| } else { |
| job = new RenderJob(); |
| } |
| job.schedule(delay); |
| job.addJobChangeListener(this); |
| mJob = job; |
| } |
| |
| /** Render immediately */ |
| private void renderSync() { |
| GraphicalEditorPart editor = mCanvas.getEditorDelegate().getGraphicalEditor(); |
| if (editor.getReadyLayoutLib(false /*displayError*/) == null) { |
| // Don't attempt to render when there is no ready layout library: most likely |
| // the targets are loading/reloading. |
| return; |
| } |
| |
| disposeThumbnail(); |
| |
| Configuration configuration = |
| mAlternateInput != null && mAlternateConfiguration != null |
| ? mAlternateConfiguration : mConfiguration; |
| ResourceResolver resolver = getResourceResolver(configuration); |
| RenderService renderService = RenderService.create(editor, configuration, resolver); |
| |
| if (mIncludedWithin != null) { |
| renderService.setIncludedWithin(mIncludedWithin); |
| } |
| |
| if (mAlternateInput != null) { |
| IAndroidTarget target = editor.getRenderingTarget(); |
| AndroidTargetData data = null; |
| if (target != null) { |
| Sdk sdk = Sdk.getCurrent(); |
| if (sdk != null) { |
| data = sdk.getTargetData(target); |
| } |
| } |
| |
| // Construct UI model from XML |
| DocumentDescriptor documentDescriptor; |
| if (data == null) { |
| documentDescriptor = new DocumentDescriptor("temp", null);//$NON-NLS-1$ |
| } else { |
| documentDescriptor = data.getLayoutDescriptors().getDescriptor(); |
| } |
| UiDocumentNode model = (UiDocumentNode) documentDescriptor.createUiNode(); |
| model.setEditor(mCanvas.getEditorDelegate().getEditor()); |
| model.setUnknownDescriptorProvider(editor.getModel().getUnknownDescriptorProvider()); |
| |
| Document document = DomUtilities.getDocument(mAlternateInput); |
| if (document == null) { |
| mError = "No document"; |
| createErrorThumbnail(); |
| return; |
| } |
| model.loadFromXmlNode(document); |
| renderService.setModel(model); |
| } else { |
| renderService.setModel(editor.getModel()); |
| } |
| RenderLogger log = editor.createRenderLogger(getDisplayName()); |
| renderService.setLog(log); |
| RenderSession session = renderService.createRenderSession(); |
| Result render = session.render(1000); |
| |
| if (DUMP_RENDER_DIAGNOSTICS) { |
| if (log.hasProblems() || !render.isSuccess()) { |
| AdtPlugin.log(IStatus.ERROR, "Found problems rendering preview " |
| + getDisplayName() + ": " |
| + render.getErrorMessage() + " : " |
| + log.getProblems(false)); |
| Throwable exception = render.getException(); |
| if (exception != null) { |
| AdtPlugin.log(exception, "Failure rendering preview " + getDisplayName()); |
| } |
| } |
| } |
| |
| if (render.isSuccess()) { |
| mError = null; |
| } else { |
| mError = render.getErrorMessage(); |
| if (mError == null) { |
| mError = ""; |
| } |
| } |
| |
| if (render.getStatus() == Status.ERROR_TIMEOUT) { |
| // TODO: Special handling? schedule update again later |
| return; |
| } |
| if (render.isSuccess()) { |
| BufferedImage image = session.getImage(); |
| if (image != null) { |
| createThumbnail(image); |
| } |
| } |
| |
| if (mError != null) { |
| createErrorThumbnail(); |
| } |
| } |
| |
| private ResourceResolver getResourceResolver(Configuration configuration) { |
| ResourceResolver resourceResolver = mResourceResolver.get(); |
| if (resourceResolver != null) { |
| return resourceResolver; |
| } |
| |
| GraphicalEditorPart graphicalEditor = mCanvas.getEditorDelegate().getGraphicalEditor(); |
| String theme = configuration.getTheme(); |
| if (theme == null) { |
| return null; |
| } |
| |
| Map<ResourceType, Map<String, ResourceValue>> configuredFrameworkRes = null; |
| Map<ResourceType, Map<String, ResourceValue>> configuredProjectRes = null; |
| |
| FolderConfiguration config = configuration.getFullConfig(); |
| IAndroidTarget target = graphicalEditor.getRenderingTarget(); |
| ResourceRepository frameworkRes = null; |
| if (target != null) { |
| Sdk sdk = Sdk.getCurrent(); |
| if (sdk == null) { |
| return null; |
| } |
| AndroidTargetData data = sdk.getTargetData(target); |
| |
| if (data != null) { |
| // TODO: SHARE if possible |
| frameworkRes = data.getFrameworkResources(); |
| configuredFrameworkRes = frameworkRes.getConfiguredResources(config); |
| } else { |
| return null; |
| } |
| } else { |
| return null; |
| } |
| assert configuredFrameworkRes != null; |
| |
| |
| // get the resources of the file's project. |
| ProjectResources projectRes = ResourceManager.getInstance().getProjectResources( |
| graphicalEditor.getProject()); |
| configuredProjectRes = projectRes.getConfiguredResources(config); |
| |
| if (!theme.startsWith(PREFIX_RESOURCE_REF)) { |
| if (frameworkRes.hasResourceItem(ANDROID_STYLE_RESOURCE_PREFIX + theme)) { |
| theme = ANDROID_STYLE_RESOURCE_PREFIX + theme; |
| } else { |
| theme = STYLE_RESOURCE_PREFIX + theme; |
| } |
| } |
| |
| resourceResolver = ResourceResolver.create( |
| configuredProjectRes, configuredFrameworkRes, |
| ResourceHelper.styleToTheme(theme), |
| ResourceHelper.isProjectStyle(theme)); |
| mResourceResolver = new SoftReference<ResourceResolver>(resourceResolver); |
| return resourceResolver; |
| } |
| |
| /** |
| * Sets the new image of the preview and generates a thumbnail |
| * |
| * @param image the full size image |
| */ |
| void createThumbnail(BufferedImage image) { |
| if (image == null) { |
| mThumbnail = null; |
| return; |
| } |
| |
| ImageOverlay imageOverlay = mCanvas.getImageOverlay(); |
| boolean drawShadows = imageOverlay == null || imageOverlay.getShowDropShadow(); |
| double scale = getWidth() / (double) image.getWidth(); |
| int shadowSize; |
| if (LARGE_SHADOWS) { |
| shadowSize = drawShadows ? SHADOW_SIZE : 0; |
| } else { |
| shadowSize = drawShadows ? SMALL_SHADOW_SIZE : 0; |
| } |
| if (scale < 1.0) { |
| if (LARGE_SHADOWS) { |
| image = ImageUtils.scale(image, scale, scale, |
| shadowSize, shadowSize); |
| if (drawShadows) { |
| ImageUtils.drawRectangleShadow(image, 0, 0, |
| image.getWidth() - shadowSize, |
| image.getHeight() - shadowSize); |
| } |
| } else { |
| image = ImageUtils.scale(image, scale, scale, |
| shadowSize, shadowSize); |
| if (drawShadows) { |
| ImageUtils.drawSmallRectangleShadow(image, 0, 0, |
| image.getWidth() - shadowSize, |
| image.getHeight() - shadowSize); |
| } |
| } |
| } |
| |
| mThumbnail = SwtUtils.convertToSwt(mCanvas.getDisplay(), image, |
| true /* transferAlpha */, -1); |
| } |
| |
| void createErrorThumbnail() { |
| int shadowSize = LARGE_SHADOWS ? SHADOW_SIZE : SMALL_SHADOW_SIZE; |
| int width = getWidth(); |
| int height = getHeight(); |
| BufferedImage image = new BufferedImage(width + shadowSize, height + shadowSize, |
| BufferedImage.TYPE_INT_ARGB); |
| |
| Graphics2D g = image.createGraphics(); |
| g.setColor(new java.awt.Color(0xfffbfcc6)); |
| g.fillRect(0, 0, width, height); |
| |
| g.dispose(); |
| |
| ImageOverlay imageOverlay = mCanvas.getImageOverlay(); |
| boolean drawShadows = imageOverlay == null || imageOverlay.getShowDropShadow(); |
| if (drawShadows) { |
| if (LARGE_SHADOWS) { |
| ImageUtils.drawRectangleShadow(image, 0, 0, |
| image.getWidth() - SHADOW_SIZE, |
| image.getHeight() - SHADOW_SIZE); |
| } else { |
| ImageUtils.drawSmallRectangleShadow(image, 0, 0, |
| image.getWidth() - SMALL_SHADOW_SIZE, |
| image.getHeight() - SMALL_SHADOW_SIZE); |
| } |
| } |
| |
| mThumbnail = SwtUtils.convertToSwt(mCanvas.getDisplay(), image, |
| true /* transferAlpha */, -1); |
| } |
| |
| private static double getScale(int width, int height) { |
| int maxWidth = RenderPreviewManager.getMaxWidth(); |
| int maxHeight = RenderPreviewManager.getMaxHeight(); |
| if (width > 0 && height > 0 |
| && (width > maxWidth || height > maxHeight)) { |
| if (width >= height) { // landscape |
| return maxWidth / (double) width; |
| } else { // portrait |
| return maxHeight / (double) height; |
| } |
| } |
| |
| return 1.0; |
| } |
| |
| /** |
| * Returns the width of the preview, in pixels |
| * |
| * @return the width in pixels |
| */ |
| public int getWidth() { |
| return (int) (mWidth * mScale * RenderPreviewManager.getScale()); |
| } |
| |
| /** |
| * Returns the height of the preview, in pixels |
| * |
| * @return the height in pixels |
| */ |
| public int getHeight() { |
| return (int) (mHeight * mScale * RenderPreviewManager.getScale()); |
| } |
| |
| /** |
| * Handles clicks within the preview (x and y are positions relative within the |
| * preview |
| * |
| * @param x the x coordinate within the preview where the click occurred |
| * @param y the y coordinate within the preview where the click occurred |
| * @return true if this preview handled (and therefore consumed) the click |
| */ |
| public boolean click(int x, int y) { |
| if (y >= mTitleHeight && y < mTitleHeight + HEADER_HEIGHT) { |
| int left = 0; |
| left += CLOSE_ICON_WIDTH; |
| if (x <= left) { |
| // Delete |
| mManager.deletePreview(this); |
| return true; |
| } |
| left += ZOOM_IN_ICON_WIDTH; |
| if (x <= left) { |
| // Zoom in |
| mScale = mScale * (1 / 0.5); |
| if (Math.abs(mScale-1.0) < 0.0001) { |
| mScale = 1.0; |
| } |
| |
| render(0); |
| mManager.layout(true); |
| mCanvas.redraw(); |
| return true; |
| } |
| left += ZOOM_OUT_ICON_WIDTH; |
| if (x <= left) { |
| // Zoom out |
| mScale = mScale * (0.5 / 1); |
| if (Math.abs(mScale-1.0) < 0.0001) { |
| mScale = 1.0; |
| } |
| render(0); |
| |
| mManager.layout(true); |
| mCanvas.redraw(); |
| return true; |
| } |
| left += EDIT_ICON_WIDTH; |
| if (x <= left) { |
| // Edit. For now, just rename |
| InputDialog d = new InputDialog( |
| AdtPlugin.getShell(), |
| "Rename Preview", // title |
| "Name:", |
| getDisplayName(), |
| null); |
| if (d.open() == Window.OK) { |
| String newName = d.getValue(); |
| mConfiguration.setDisplayName(newName); |
| if (mDescription != null) { |
| mManager.rename(mDescription, newName); |
| } |
| mCanvas.redraw(); |
| } |
| |
| return true; |
| } |
| |
| // Clicked anywhere else on header |
| // Perhaps open Edit dialog here? |
| } |
| |
| mManager.switchTo(this); |
| return true; |
| } |
| |
| /** |
| * Paints the preview at the given x/y position |
| * |
| * @param gc the graphics context to paint it into |
| * @param x the x coordinate to paint the preview at |
| * @param y the y coordinate to paint the preview at |
| */ |
| void paint(GC gc, int x, int y) { |
| mTitleHeight = paintTitle(gc, x, y, true /*showFile*/); |
| y += mTitleHeight; |
| y += 2; |
| |
| int width = getWidth(); |
| int height = getHeight(); |
| if (mThumbnail != null && mError == null) { |
| gc.drawImage(mThumbnail, x, y); |
| |
| if (mActive) { |
| int oldWidth = gc.getLineWidth(); |
| gc.setLineWidth(3); |
| gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_LIST_SELECTION)); |
| gc.drawRectangle(x - 1, y - 1, width + 2, height + 2); |
| gc.setLineWidth(oldWidth); |
| } |
| } else if (mError != null) { |
| if (mThumbnail != null) { |
| gc.drawImage(mThumbnail, x, y); |
| } else { |
| gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BORDER)); |
| gc.drawRectangle(x, y, width, height); |
| } |
| |
| gc.setClipping(x, y, width, height); |
| Image icon = IconFactory.getInstance().getIcon("renderError"); //$NON-NLS-1$ |
| ImageData data = icon.getImageData(); |
| int prevAlpha = gc.getAlpha(); |
| int alpha = 96; |
| if (mThumbnail != null) { |
| alpha -= 32; |
| } |
| gc.setAlpha(alpha); |
| gc.drawImage(icon, x + (width - data.width) / 2, y + (height - data.height) / 2); |
| |
| String msg = mError; |
| Density density = mConfiguration.getDensity(); |
| if (density == Density.TV || density == Density.LOW) { |
| msg = "Broken rendering library; unsupported DPI. Try using the SDK manager " + |
| "to get updated layout libraries."; |
| } |
| int charWidth = gc.getFontMetrics().getAverageCharWidth(); |
| int charsPerLine = (width - 10) / charWidth; |
| msg = SdkUtils.wrap(msg, charsPerLine, null); |
| gc.setAlpha(255); |
| gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_BLACK)); |
| gc.drawText(msg, x + 5, y + HEADER_HEIGHT, true); |
| gc.setAlpha(prevAlpha); |
| gc.setClipping((Region) null); |
| } else { |
| gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BORDER)); |
| gc.drawRectangle(x, y, width, height); |
| |
| Image icon = IconFactory.getInstance().getIcon("refreshPreview"); //$NON-NLS-1$ |
| ImageData data = icon.getImageData(); |
| int prevAlpha = gc.getAlpha(); |
| gc.setAlpha(96); |
| gc.drawImage(icon, x + (width - data.width) / 2, |
| y + (height - data.height) / 2); |
| gc.setAlpha(prevAlpha); |
| } |
| |
| if (mActive) { |
| int left = x ; |
| int prevAlpha = gc.getAlpha(); |
| gc.setAlpha(208); |
| Color bg = mCanvas.getDisplay().getSystemColor(SWT.COLOR_WHITE); |
| gc.setBackground(bg); |
| gc.fillRectangle(left, y, x + width - left, HEADER_HEIGHT); |
| gc.setAlpha(prevAlpha); |
| |
| y += 2; |
| |
| // Paint icons |
| gc.drawImage(CLOSE_ICON, left, y); |
| left += CLOSE_ICON_WIDTH; |
| |
| gc.drawImage(ZOOM_IN_ICON, left, y); |
| left += ZOOM_IN_ICON_WIDTH; |
| |
| gc.drawImage(ZOOM_OUT_ICON, left, y); |
| left += ZOOM_OUT_ICON_WIDTH; |
| |
| gc.drawImage(EDIT_ICON, left, y); |
| left += EDIT_ICON_WIDTH; |
| } |
| } |
| |
| /** |
| * Paints the preview title at the given position (and returns the required |
| * height) |
| * |
| * @param gc the graphics context to paint into |
| * @param x the left edge of the preview rectangle |
| * @param y the top edge of the preview rectangle |
| */ |
| private int paintTitle(GC gc, int x, int y, boolean showFile) { |
| String displayName = getDisplayName(); |
| return paintTitle(gc, x, y, showFile, displayName); |
| } |
| |
| /** |
| * Paints the preview title at the given position (and returns the required |
| * height) |
| * |
| * @param gc the graphics context to paint into |
| * @param x the left edge of the preview rectangle |
| * @param y the top edge of the preview rectangle |
| * @param displayName the title string to be used |
| */ |
| int paintTitle(GC gc, int x, int y, boolean showFile, String displayName) { |
| int titleHeight = 0; |
| |
| if (showFile && mIncludedWithin != null) { |
| if (mManager.getMode() != INCLUDES) { |
| displayName = "<include>"; |
| } else { |
| // Skip: just paint footer instead |
| displayName = null; |
| } |
| } |
| |
| int width = getWidth(); |
| int labelTop = y + 1; |
| gc.setClipping(x, labelTop, width, 100); |
| |
| // Use font height rather than extent height since we want two adjacent |
| // previews (which may have different display names and therefore end |
| // up with slightly different extent heights) to have identical title |
| // heights such that they are aligned identically |
| int fontHeight = gc.getFontMetrics().getHeight(); |
| |
| if (displayName != null && displayName.length() > 0) { |
| gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_WHITE)); |
| Point extent = gc.textExtent(displayName); |
| int labelLeft = Math.max(x, x + (width - extent.x) / 2); |
| Image icon = null; |
| Locale locale = mConfiguration.getLocale(); |
| if (locale != null && (locale.hasLanguage() || locale.hasRegion()) |
| && (!(mConfiguration instanceof NestedConfiguration) |
| || ((NestedConfiguration) mConfiguration).isOverridingLocale())) { |
| icon = locale.getFlagImage(); |
| } |
| |
| if (icon != null) { |
| int flagWidth = icon.getImageData().width; |
| int flagHeight = icon.getImageData().height; |
| labelLeft = Math.max(x + flagWidth / 2, labelLeft); |
| gc.drawImage(icon, labelLeft - flagWidth / 2 - 1, labelTop); |
| labelLeft += flagWidth / 2 + 1; |
| gc.drawText(displayName, labelLeft, |
| labelTop - (extent.y - flagHeight) / 2, true); |
| } else { |
| gc.drawText(displayName, labelLeft, labelTop, true); |
| } |
| |
| labelTop += extent.y; |
| titleHeight += fontHeight; |
| } |
| |
| if (showFile && (mAlternateInput != null || mIncludedWithin != null)) { |
| // Draw file flag, and parent folder name |
| IFile file = mAlternateInput != null |
| ? mAlternateInput : mIncludedWithin.getFile(); |
| String fileName = file.getParent().getName() + File.separator |
| + file.getName(); |
| Point extent = gc.textExtent(fileName); |
| Image icon = IconFactory.getInstance().getIcon("android_file"); //$NON-NLS-1$ |
| int flagWidth = icon.getImageData().width; |
| int flagHeight = icon.getImageData().height; |
| |
| int labelLeft = Math.max(x, x + (width - extent.x - flagWidth - 1) / 2); |
| |
| gc.drawImage(icon, labelLeft, labelTop); |
| |
| gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_GRAY)); |
| labelLeft += flagWidth + 1; |
| labelTop -= (extent.y - flagHeight) / 2; |
| gc.drawText(fileName, labelLeft, labelTop, true); |
| |
| titleHeight += Math.max(titleHeight, icon.getImageData().height); |
| } |
| |
| gc.setClipping((Region) null); |
| |
| return titleHeight; |
| } |
| |
| /** |
| * Notifies that the preview's configuration has changed. |
| * |
| * @param flags the change flags, a bitmask corresponding to the |
| * {@code CHANGE_} constants in {@link ConfigurationClient} |
| */ |
| public void configurationChanged(int flags) { |
| if (!mVisible) { |
| mDirty |= flags; |
| return; |
| } |
| |
| if ((flags & MASK_RENDERING) != 0) { |
| mResourceResolver.clear(); |
| // Handle inheritance |
| mConfiguration.syncFolderConfig(); |
| updateForkStatus(); |
| updateSize(); |
| } |
| |
| // Sanity check to make sure things are working correctly |
| if (DEBUG) { |
| RenderPreviewMode mode = mManager.getMode(); |
| if (mode == DEFAULT) { |
| assert mConfiguration instanceof VaryingConfiguration; |
| VaryingConfiguration config = (VaryingConfiguration) mConfiguration; |
| int alternateFlags = config.getAlternateFlags(); |
| switch (alternateFlags) { |
| case Configuration.CFG_DEVICE_STATE: { |
| State configState = config.getDeviceState(); |
| State chooserState = mManager.getChooser().getConfiguration() |
| .getDeviceState(); |
| assert configState != null && chooserState != null; |
| assert !configState.getName().equals(chooserState.getName()) |
| : configState.toString() + ':' + chooserState; |
| |
| Device configDevice = config.getDevice(); |
| Device chooserDevice = mManager.getChooser().getConfiguration() |
| .getDevice(); |
| assert configDevice != null && chooserDevice != null; |
| assert configDevice == chooserDevice |
| : configDevice.toString() + ':' + chooserDevice; |
| |
| break; |
| } |
| case Configuration.CFG_DEVICE: { |
| Device configDevice = config.getDevice(); |
| Device chooserDevice = mManager.getChooser().getConfiguration() |
| .getDevice(); |
| assert configDevice != null && chooserDevice != null; |
| assert configDevice != chooserDevice |
| : configDevice.toString() + ':' + chooserDevice; |
| |
| State configState = config.getDeviceState(); |
| State chooserState = mManager.getChooser().getConfiguration() |
| .getDeviceState(); |
| assert configState != null && chooserState != null; |
| assert configState.getName().equals(chooserState.getName()) |
| : configState.toString() + ':' + chooserState; |
| |
| break; |
| } |
| case Configuration.CFG_LOCALE: { |
| Locale configLocale = config.getLocale(); |
| Locale chooserLocale = mManager.getChooser().getConfiguration() |
| .getLocale(); |
| assert configLocale != null && chooserLocale != null; |
| assert configLocale != chooserLocale |
| : configLocale.toString() + ':' + chooserLocale; |
| break; |
| } |
| default: { |
| // Some other type of override I didn't anticipate |
| assert false : alternateFlags; |
| } |
| } |
| } |
| } |
| |
| mDirty = 0; |
| mManager.scheduleRender(this); |
| } |
| |
| private void updateSize() { |
| Device device = mConfiguration.getDevice(); |
| if (device == null) { |
| return; |
| } |
| Screen screen = device.getDefaultHardware().getScreen(); |
| if (screen == null) { |
| return; |
| } |
| |
| FolderConfiguration folderConfig = mConfiguration.getFullConfig(); |
| ScreenOrientationQualifier qualifier = folderConfig.getScreenOrientationQualifier(); |
| ScreenOrientation orientation = qualifier == null |
| ? ScreenOrientation.PORTRAIT : qualifier.getValue(); |
| |
| // compute width and height to take orientation into account. |
| int x = screen.getXDimension(); |
| int y = screen.getYDimension(); |
| int screenWidth, screenHeight; |
| |
| if (x > y) { |
| if (orientation == ScreenOrientation.LANDSCAPE) { |
| screenWidth = x; |
| screenHeight = y; |
| } else { |
| screenWidth = y; |
| screenHeight = x; |
| } |
| } else { |
| if (orientation == ScreenOrientation.LANDSCAPE) { |
| screenWidth = y; |
| screenHeight = x; |
| } else { |
| screenWidth = x; |
| screenHeight = y; |
| } |
| } |
| |
| int width = RenderPreviewManager.getMaxWidth(); |
| int height = RenderPreviewManager.getMaxHeight(); |
| if (screenWidth > 0) { |
| double scale = getScale(screenWidth, screenHeight); |
| width = (int) (screenWidth * scale); |
| height = (int) (screenHeight * scale); |
| } |
| |
| if (width != mWidth || height != mHeight) { |
| mWidth = width; |
| mHeight = height; |
| |
| Image thumbnail = mThumbnail; |
| mThumbnail = null; |
| if (thumbnail != null) { |
| thumbnail.dispose(); |
| } |
| if (mHeight != 0) { |
| mAspectRatio = mWidth / (double) mHeight; |
| } |
| } |
| } |
| |
| /** |
| * Returns the configuration associated with this preview |
| * |
| * @return the configuration |
| */ |
| @NonNull |
| public Configuration getConfiguration() { |
| return mConfiguration; |
| } |
| |
| // ---- Implements IJobChangeListener ---- |
| |
| @Override |
| public void aboutToRun(IJobChangeEvent event) { |
| } |
| |
| @Override |
| public void awake(IJobChangeEvent event) { |
| } |
| |
| @Override |
| public void done(IJobChangeEvent event) { |
| mJob = null; |
| } |
| |
| @Override |
| public void running(IJobChangeEvent event) { |
| } |
| |
| @Override |
| public void scheduled(IJobChangeEvent event) { |
| } |
| |
| @Override |
| public void sleeping(IJobChangeEvent event) { |
| } |
| |
| // ---- Delayed Rendering ---- |
| |
| private final class RenderJob extends UIJob { |
| public RenderJob() { |
| super("RenderPreview"); |
| setSystem(true); |
| setUser(false); |
| } |
| |
| @Override |
| public IStatus runInUIThread(IProgressMonitor monitor) { |
| mJob = null; |
| if (!mCanvas.isDisposed()) { |
| renderSync(); |
| mCanvas.redraw(); |
| return org.eclipse.core.runtime.Status.OK_STATUS; |
| } |
| |
| return org.eclipse.core.runtime.Status.CANCEL_STATUS; |
| } |
| |
| @Override |
| public Display getDisplay() { |
| if (mCanvas.isDisposed()) { |
| return null; |
| } |
| return mCanvas.getDisplay(); |
| } |
| } |
| |
| private final class AsyncRenderJob extends Job { |
| public AsyncRenderJob() { |
| super("RenderPreview"); |
| setSystem(true); |
| setUser(false); |
| } |
| |
| @Override |
| protected IStatus run(IProgressMonitor monitor) { |
| mJob = null; |
| |
| if (mCanvas.isDisposed()) { |
| return org.eclipse.core.runtime.Status.CANCEL_STATUS; |
| } |
| |
| renderSync(); |
| |
| // Update display |
| mCanvas.getDisplay().asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| mCanvas.redraw(); |
| } |
| }); |
| |
| return org.eclipse.core.runtime.Status.OK_STATUS; |
| } |
| } |
| |
| /** |
| * Sets the input file to use for rendering. If not set, this will just be |
| * the same file as the configuration chooser. This is used to render other |
| * layouts, such as variations of the currently edited layout, which are |
| * not kept in sync with the main layout. |
| * |
| * @param file the file to set as input |
| */ |
| public void setAlternateInput(@Nullable IFile file) { |
| mAlternateInput = file; |
| } |
| |
| /** Corresponding description for this preview if it is a manually added preview */ |
| private @Nullable ConfigurationDescription mDescription; |
| |
| /** |
| * Sets the description of this preview, if this preview is a manually added preview |
| * |
| * @param description the description of this preview |
| */ |
| public void setDescription(@Nullable ConfigurationDescription description) { |
| mDescription = description; |
| } |
| |
| /** |
| * Returns the description of this preview, if this preview is a manually added preview |
| * |
| * @return the description |
| */ |
| @Nullable |
| public ConfigurationDescription getDescription() { |
| return mDescription; |
| } |
| |
| @Override |
| public String toString() { |
| return getDisplayName() + ':' + mConfiguration; |
| } |
| |
| /** Sorts render previews into increasing aspect ratio order */ |
| static Comparator<RenderPreview> INCREASING_ASPECT_RATIO = new Comparator<RenderPreview>() { |
| @Override |
| public int compare(RenderPreview preview1, RenderPreview preview2) { |
| return (int) Math.signum(preview1.mAspectRatio - preview2.mAspectRatio); |
| } |
| }; |
| /** Sorts render previews into visual order: row by row, column by column */ |
| static Comparator<RenderPreview> VISUAL_ORDER = new Comparator<RenderPreview>() { |
| @Override |
| public int compare(RenderPreview preview1, RenderPreview preview2) { |
| int delta = preview1.mY - preview2.mY; |
| if (delta == 0) { |
| delta = preview1.mX - preview2.mX; |
| } |
| return delta; |
| } |
| }; |
| } |
