android/src/com/android/tools/idea/ddms/screenshot/ScreenshotViewer.java - platform/tools/adt/idea - Git at Google

 /*
  * 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.ddms.screenshot;

 import com.android.SdkConstants;
 import com.android.ddmlib.IDevice;
 import com.android.resources.ScreenOrientation;
 import com.android.tools.idea.rendering.ImageUtils;
 import com.intellij.icons.AllIcons;
 import com.intellij.openapi.actionSystem.DataProvider;
 import com.intellij.openapi.actionSystem.PlatformDataKeys;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.fileChooser.FileChooserFactory;
 import com.intellij.openapi.fileChooser.FileSaverDescriptor;
 import com.intellij.openapi.fileChooser.FileSaverDialog;
 import com.intellij.openapi.fileEditor.FileEditorProvider;
 import com.intellij.openapi.fileEditor.ex.FileEditorProviderManager;
 import com.intellij.openapi.progress.ProgressIndicator;
 import com.intellij.openapi.progress.Task;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.util.Condition;
 import com.intellij.openapi.vfs.*;
 import com.intellij.ui.components.JBScrollPane;
 import com.intellij.util.containers.ContainerUtil;
 import org.intellij.images.editor.ImageEditor;
 import org.intellij.images.editor.ImageFileEditor;
 import org.intellij.images.editor.ImageZoomModel;
 import org.jetbrains.android.util.AndroidBundle;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import javax.imageio.ImageIO;
 import javax.swing.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
 import java.util.Calendar;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;

 public class ScreenshotViewer extends DialogWrapper implements DataProvider {
   @NonNls private static final String SCREENSHOT_VIEWER_DIMENSIONS_KEY = "ScreenshotViewer.Dimensions";

   private static VirtualFile ourLastSavedFolder = null;

   private final Project myProject;
   private final IDevice myDevice;

   private final VirtualFile myBackingVirtualFile;
   private final ImageFileEditor myImageFileEditor;
   private final FileEditorProvider myProvider;

   private final List<DeviceArtDescriptor> myDeviceArtDescriptors;

   private JPanel myPanel;
   private JButton myRefreshButton;
   private JButton myRotateButton;
   private JBScrollPane myScrollPane;
   private JCheckBox myFrameScreenshotCheckBox;
   private JComboBox myDeviceArtCombo;
   private JCheckBox myDropShadowCheckBox;
   private JCheckBox myScreenGlareCheckBox;

   /** Angle in degrees by which the screenshot from the device has been rotated. One of 0, 90, 180 or 270. */
   private int myRotationAngle = 0;

   /**
    * Reference to the screenshot obtained from the device and then rotated by {@link #myRotationAngle} degrees.
    * Accessed from both EDT and background threads.
    */
   private AtomicReference<BufferedImage> mySourceImageRef = new AtomicReference<BufferedImage>();

   /** Reference to the framed screenshot displayed on screen. Accessed from both EDT and background threads. */
   private AtomicReference<BufferedImage> myDisplayedImageRef = new AtomicReference<BufferedImage>();

   /** User specified destination where the screenshot is saved. */
   private File myScreenshotFile;

   public ScreenshotViewer(@NotNull Project project,
                           @NotNull BufferedImage image,
                           @NotNull File backingFile,
                           @Nullable IDevice device,
                           @Nullable String deviceModel) {
     super(project, true);

     myProject = project;
     myDevice = device;
     mySourceImageRef.set(image);
     myDisplayedImageRef.set(image);

     myBackingVirtualFile = LocalFileSystem.getInstance().findFileByIoFile(backingFile);
     assert myBackingVirtualFile != null;

     myRefreshButton.setIcon(AllIcons.Actions.Refresh);
     myRefreshButton.setEnabled(device != null);
     myRotateButton.setIcon(AllIcons.Actions.AllRight);

     myProvider = getImageFileEditorProvider();
     myImageFileEditor = (ImageFileEditor)myProvider.createEditor(myProject, myBackingVirtualFile);
     myScrollPane.getViewport().add(myImageFileEditor.getComponent());

     ActionListener l = new ActionListener() {
       @Override
       public void actionPerformed(ActionEvent actionEvent) {
         if (actionEvent.getSource() == myRefreshButton) {
           doRefreshScreenshot();
         } else if (actionEvent.getSource() == myRotateButton) {
           doRotateScreenshot();
         } else if (actionEvent.getSource() == myFrameScreenshotCheckBox
                    || actionEvent.getSource() == myDeviceArtCombo
                    || actionEvent.getSource() == myDropShadowCheckBox
                    || actionEvent.getSource() == myScreenGlareCheckBox) {
           doFrameScreenshot();
         }
       }
     };

     myRefreshButton.addActionListener(l);
     myRotateButton.addActionListener(l);
     myFrameScreenshotCheckBox.addActionListener(l);
     myDeviceArtCombo.addActionListener(l);
     myDropShadowCheckBox.addActionListener(l);
     myScreenGlareCheckBox.addActionListener(l);

     myDeviceArtDescriptors = getDescriptorsToFrame(image);
     String[] titles = new String[myDeviceArtDescriptors.size()];
     for (int i = 0; i < myDeviceArtDescriptors.size(); i++) {
       titles[i] = myDeviceArtDescriptors.get(i).getName();
     }
     DefaultComboBoxModel model = new DefaultComboBoxModel(titles);
     myDeviceArtCombo.setModel(model);

     // Set the default device art descriptor selection
     myDeviceArtCombo.setSelectedIndex(getDefaultDescriptor(myDeviceArtDescriptors, image, deviceModel));

     setModal(false);
     init();
   }

   // returns the list of descriptors capable of framing the given image
   private List<DeviceArtDescriptor> getDescriptorsToFrame(final BufferedImage image) {
     double imgAspectRatio = image.getWidth() / (double) image.getHeight();
     final ScreenOrientation orientation =
       imgAspectRatio >= (1 - ImageUtils.EPSILON) ? ScreenOrientation.LANDSCAPE : ScreenOrientation.PORTRAIT;

     List<DeviceArtDescriptor> allDescriptors = DeviceArtDescriptor.getDescriptors(null);
     return ContainerUtil.filter(allDescriptors, new Condition<DeviceArtDescriptor>() {
       @Override
       public boolean value(DeviceArtDescriptor descriptor) {
         return descriptor.canFrameImage(image, orientation);
       }
     });
   }

   private static int getDefaultDescriptor(List<DeviceArtDescriptor> deviceArtDescriptors, BufferedImage image,
                                           @Nullable String deviceModel) {
     int index = -1;

     if (deviceModel != null) {
       index = findDescriptorIndexForProduct(deviceArtDescriptors, deviceModel);
     }

     if (index < 0) {
       // Assume that if the min resolution is > 1280, then we are on a tablet
       String defaultDevice = Math.min(image.getWidth(), image.getHeight()) > 1280 ? "Generic Tablet" : "Generic Phone";
       index = findDescriptorIndexForProduct(deviceArtDescriptors, defaultDevice);
     }

     // If we can't find anything (which shouldn't happen since we should get the Generic Phone/Tablet),
     // default to the first one.
     if (index < 0) {
       index = 0;
     }

     return index;
   }

   private static int findDescriptorIndexForProduct(List<DeviceArtDescriptor> descriptors, String deviceModel) {
     for (int i = 0; i < descriptors.size(); i++) {
       DeviceArtDescriptor d = descriptors.get(i);
       if (d.getName().equalsIgnoreCase(deviceModel)) {
         return i;
       }
     }
     return -1;
   }

   @Override
   protected void dispose() {
     myProvider.disposeEditor(myImageFileEditor);
     super.dispose();
   }

   private void doRefreshScreenshot() {
     assert myDevice != null;
     new ScreenshotTask(myProject, myDevice) {
       @Override
       public void onSuccess() {
         String msg = getError();
         if (msg != null) {
           Messages.showErrorDialog(myProject, msg, AndroidBundle.message("android.ddms.actions.screenshot"));
           return;
         }

         BufferedImage image = getScreenshot();
         mySourceImageRef.set(image);
         processScreenshot(myFrameScreenshotCheckBox.isSelected(), myRotationAngle);
       }
     }.queue();
   }

   private void doRotateScreenshot() {
     myRotationAngle = (myRotationAngle + 90) % 360;
     processScreenshot(myFrameScreenshotCheckBox.isSelected(), 90);
   }

   private void doFrameScreenshot() {
     boolean shouldFrame = myFrameScreenshotCheckBox.isSelected();

     myDeviceArtCombo.setEnabled(shouldFrame);
     myDropShadowCheckBox.setEnabled(shouldFrame);
     myScreenGlareCheckBox.setEnabled(shouldFrame);

     if (shouldFrame) {
       processScreenshot(true, 0);
     } else {
       myDisplayedImageRef.set(mySourceImageRef.get());
       updateEditorImage();
     }
   }

   private void processScreenshot(boolean addFrame, int rotateByAngle) {
     DeviceArtDescriptor spec = addFrame ? myDeviceArtDescriptors.get(myDeviceArtCombo.getSelectedIndex()) : null;
     boolean shadow = addFrame && myDropShadowCheckBox.isSelected();
     boolean reflection = addFrame && myScreenGlareCheckBox.isSelected();

     new ImageProcessorTask(myProject, mySourceImageRef.get(), rotateByAngle, spec, shadow, reflection, myBackingVirtualFile) {
       @Override
       public void onSuccess() {
         mySourceImageRef.set(getRotatedImage());
         myDisplayedImageRef.set(getProcessedImage());
         updateEditorImage();
       }
     }.queue();
   }

   private static class ImageProcessorTask extends Task.Modal {
     private final BufferedImage mySrcImage;
     private final int myRotationAngle;
     private final DeviceArtDescriptor myDescriptor;
     private final boolean myAddShadow;
     private final boolean myAddReflection;
     private final VirtualFile myDestinationFile;

     private BufferedImage myRotatedImage;
     private BufferedImage myProcessedImage;

     public ImageProcessorTask(@Nullable Project project,
                               @NotNull BufferedImage srcImage,
                               int rotateByAngle,
                               @Nullable DeviceArtDescriptor descriptor,
                               boolean addShadow,
                               boolean addReflection,
                               VirtualFile writeToFile) {
       super(project, AndroidBundle.message("android.ddms.screenshot.image.processor.task.title"), false);

       mySrcImage = srcImage;
       myRotationAngle = rotateByAngle;
       myDescriptor = descriptor;
       myAddShadow = addShadow;
       myAddReflection = addReflection;
       myDestinationFile = writeToFile;
     }

     @Override
     public void run(@NotNull ProgressIndicator indicator) {
       if (myRotationAngle != 0) {
         myRotatedImage = ImageUtils.rotateByRightAngle(mySrcImage, myRotationAngle);
       } else {
         myRotatedImage = mySrcImage;
       }

       if (myDescriptor != null) {
         myProcessedImage = DeviceArtPainter.createFrame(myRotatedImage, myDescriptor, myAddShadow, myAddReflection);
       } else {
         myProcessedImage = myRotatedImage;
       }

       myProcessedImage = ImageUtils.cropBlank(myProcessedImage, null);

       // update backing file, this is necessary for operations that read the backing file from the editor,
       // such as: Right click image -> Open in external editor
       if (myDestinationFile != null) {
         File file = VfsUtilCore.virtualToIoFile(myDestinationFile);
         try {
           ImageIO.write(myProcessedImage, SdkConstants.EXT_PNG, file);
         }
         catch (IOException e) {
           Logger.getInstance(ImageProcessorTask.class).error("Unexpected error while writing to backing file", e);
         }
       }
     }

     protected BufferedImage getProcessedImage() {
       return myProcessedImage;
     }

     protected BufferedImage getRotatedImage() {
       return myRotatedImage;
     }
   }

   private void updateEditorImage() {
     BufferedImage image = myDisplayedImageRef.get();
     ImageEditor imageEditor = myImageFileEditor.getImageEditor();

     ImageZoomModel zoomModel = imageEditor.getZoomModel();
     double zoom = zoomModel.getZoomFactor();

     imageEditor.getDocument().setValue(image);
     pack();

     zoomModel.setZoomFactor(zoom);
   }

   private FileEditorProvider getImageFileEditorProvider() {
     FileEditorProvider[] providers = FileEditorProviderManager.getInstance().getProviders(myProject, myBackingVirtualFile);
     assert providers.length > 0;

     // Note: In case there are multiple providers for image files, we'd prefer to get the bundled
     // image editor, but we don't have access to any of its implementation details so we rely
     // on the editor type id being "images" as defined by ImageFileEditorProvider#EDITOR_TYPE_ID.
     for (FileEditorProvider p : providers) {
       if (p.getEditorTypeId().equals("images")) {
         return p;
       }
     }

     return providers[0];
   }

   @Nullable
   @Override
   protected JComponent createCenterPanel() {
     return myPanel;
   }

   @NonNls
   @Override
   @Nullable
   protected String getDimensionServiceKey() {
     return SCREENSHOT_VIEWER_DIMENSIONS_KEY;
   }

   @Nullable
   @Override
   public Object getData(@NonNls String dataId) {
     // This is required since the Image Editor's actions are dependent on the context
     // being a ImageFileEditor.
     return PlatformDataKeys.FILE_EDITOR.getName().equals(dataId) ? myImageFileEditor : null;
   }

   @Override
   protected void createDefaultActions() {
     super.createDefaultActions();
     getOKAction().putValue(Action.NAME, AndroidBundle.message("android.ddms.screenshot.save.ok.button.text"));
   }

   @Override
   protected void doOKAction() {
     FileSaverDescriptor descriptor =
       new FileSaverDescriptor(AndroidBundle.message("android.ddms.screenshot.save.title"), "", SdkConstants.EXT_PNG);
     FileSaverDialog saveFileDialog = FileChooserFactory.getInstance().createSaveFileDialog(descriptor, myProject);
     VirtualFile baseDir = ourLastSavedFolder != null ? ourLastSavedFolder : myProject.getBaseDir();
     VirtualFileWrapper fileWrapper = saveFileDialog.save(baseDir, getDefaultFileName());
     if (fileWrapper == null) {
       return;
     }

     myScreenshotFile = fileWrapper.getFile();
     try {
       ImageIO.write(myDisplayedImageRef.get(), SdkConstants.EXT_PNG, myScreenshotFile);
     }
     catch (IOException e) {
       Messages.showErrorDialog(myProject,
                                AndroidBundle.message("android.ddms.screenshot.save.error", e),
                                AndroidBundle.message("android.ddms.actions.screenshot"));
       return;
     }

     VirtualFile virtualFile = fileWrapper.getVirtualFile();
     if (virtualFile != null) {
       //noinspection AssignmentToStaticFieldFromInstanceMethod
       ourLastSavedFolder = virtualFile.getParent();
     }

     super.doOKAction();
   }

   private String getDefaultFileName() {
     Calendar now = Calendar.getInstance();
     return String.format("%s-%tF-%tH%tM%tS.png", myDevice != null ? "device" : "layout", now, now, now, now);
   }

   public File getScreenshot() {
     return myScreenshotFile;
   }
 }
	/*
	* 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.ddms.screenshot;

	import com.android.SdkConstants;
	import com.android.ddmlib.IDevice;
	import com.android.resources.ScreenOrientation;
	import com.android.tools.idea.rendering.ImageUtils;
	import com.intellij.icons.AllIcons;
	import com.intellij.openapi.actionSystem.DataProvider;
	import com.intellij.openapi.actionSystem.PlatformDataKeys;
	import com.intellij.openapi.diagnostic.Logger;
	import com.intellij.openapi.fileChooser.FileChooserFactory;
	import com.intellij.openapi.fileChooser.FileSaverDescriptor;
	import com.intellij.openapi.fileChooser.FileSaverDialog;
	import com.intellij.openapi.fileEditor.FileEditorProvider;
	import com.intellij.openapi.fileEditor.ex.FileEditorProviderManager;
	import com.intellij.openapi.progress.ProgressIndicator;
	import com.intellij.openapi.progress.Task;
	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.ui.DialogWrapper;
	import com.intellij.openapi.ui.Messages;
	import com.intellij.openapi.util.Condition;
	import com.intellij.openapi.vfs.*;
	import com.intellij.ui.components.JBScrollPane;
	import com.intellij.util.containers.ContainerUtil;
	import org.intellij.images.editor.ImageEditor;
	import org.intellij.images.editor.ImageFileEditor;
	import org.intellij.images.editor.ImageZoomModel;
	import org.jetbrains.android.util.AndroidBundle;
	import org.jetbrains.annotations.NonNls;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;

	import javax.imageio.ImageIO;
	import javax.swing.*;
	import java.awt.event.ActionEvent;
	import java.awt.event.ActionListener;
	import java.awt.image.BufferedImage;
	import java.io.File;
	import java.io.IOException;
	import java.util.Calendar;
	import java.util.List;
	import java.util.concurrent.atomic.AtomicReference;

	public class ScreenshotViewer extends DialogWrapper implements DataProvider {
	@NonNls private static final String SCREENSHOT_VIEWER_DIMENSIONS_KEY = "ScreenshotViewer.Dimensions";

	private static VirtualFile ourLastSavedFolder = null;

	private final Project myProject;
	private final IDevice myDevice;

	private final VirtualFile myBackingVirtualFile;
	private final ImageFileEditor myImageFileEditor;
	private final FileEditorProvider myProvider;

	private final List<DeviceArtDescriptor> myDeviceArtDescriptors;

	private JPanel myPanel;
	private JButton myRefreshButton;
	private JButton myRotateButton;
	private JBScrollPane myScrollPane;
	private JCheckBox myFrameScreenshotCheckBox;
	private JComboBox myDeviceArtCombo;
	private JCheckBox myDropShadowCheckBox;
	private JCheckBox myScreenGlareCheckBox;

	/** Angle in degrees by which the screenshot from the device has been rotated. One of 0, 90, 180 or 270. */
	private int myRotationAngle = 0;

	/**
	* Reference to the screenshot obtained from the device and then rotated by {@link #myRotationAngle} degrees.
	* Accessed from both EDT and background threads.
	*/
	private AtomicReference<BufferedImage> mySourceImageRef = new AtomicReference<BufferedImage>();

	/** Reference to the framed screenshot displayed on screen. Accessed from both EDT and background threads. */
	private AtomicReference<BufferedImage> myDisplayedImageRef = new AtomicReference<BufferedImage>();

	/** User specified destination where the screenshot is saved. */
	private File myScreenshotFile;

	public ScreenshotViewer(@NotNull Project project,
	@NotNull BufferedImage image,
	@NotNull File backingFile,
	@Nullable IDevice device,
	@Nullable String deviceModel) {
	super(project, true);

	myProject = project;
	myDevice = device;
	mySourceImageRef.set(image);
	myDisplayedImageRef.set(image);

	myBackingVirtualFile = LocalFileSystem.getInstance().findFileByIoFile(backingFile);
	assert myBackingVirtualFile != null;

	myRefreshButton.setIcon(AllIcons.Actions.Refresh);
	myRefreshButton.setEnabled(device != null);
	myRotateButton.setIcon(AllIcons.Actions.AllRight);

	myProvider = getImageFileEditorProvider();
	myImageFileEditor = (ImageFileEditor)myProvider.createEditor(myProject, myBackingVirtualFile);
	myScrollPane.getViewport().add(myImageFileEditor.getComponent());

	ActionListener l = new ActionListener() {
	@Override
	public void actionPerformed(ActionEvent actionEvent) {
	if (actionEvent.getSource() == myRefreshButton) {
	doRefreshScreenshot();
	} else if (actionEvent.getSource() == myRotateButton) {
	doRotateScreenshot();
	} else if (actionEvent.getSource() == myFrameScreenshotCheckBox
	\|\| actionEvent.getSource() == myDeviceArtCombo
	\|\| actionEvent.getSource() == myDropShadowCheckBox
	\|\| actionEvent.getSource() == myScreenGlareCheckBox) {
	doFrameScreenshot();
	}
	}
	};

	myRefreshButton.addActionListener(l);
	myRotateButton.addActionListener(l);
	myFrameScreenshotCheckBox.addActionListener(l);
	myDeviceArtCombo.addActionListener(l);
	myDropShadowCheckBox.addActionListener(l);
	myScreenGlareCheckBox.addActionListener(l);

	myDeviceArtDescriptors = getDescriptorsToFrame(image);
	String[] titles = new String[myDeviceArtDescriptors.size()];
	for (int i = 0; i < myDeviceArtDescriptors.size(); i++) {
	titles[i] = myDeviceArtDescriptors.get(i).getName();
	}
	DefaultComboBoxModel model = new DefaultComboBoxModel(titles);
	myDeviceArtCombo.setModel(model);

	// Set the default device art descriptor selection
	myDeviceArtCombo.setSelectedIndex(getDefaultDescriptor(myDeviceArtDescriptors, image, deviceModel));

	setModal(false);
	init();
	}

	// returns the list of descriptors capable of framing the given image
	private List<DeviceArtDescriptor> getDescriptorsToFrame(final BufferedImage image) {
	double imgAspectRatio = image.getWidth() / (double) image.getHeight();
	final ScreenOrientation orientation =
	imgAspectRatio >= (1 - ImageUtils.EPSILON) ? ScreenOrientation.LANDSCAPE : ScreenOrientation.PORTRAIT;

	List<DeviceArtDescriptor> allDescriptors = DeviceArtDescriptor.getDescriptors(null);
	return ContainerUtil.filter(allDescriptors, new Condition<DeviceArtDescriptor>() {
	@Override
	public boolean value(DeviceArtDescriptor descriptor) {
	return descriptor.canFrameImage(image, orientation);
	}
	});
	}

	private static int getDefaultDescriptor(List<DeviceArtDescriptor> deviceArtDescriptors, BufferedImage image,
	@Nullable String deviceModel) {
	int index = -1;

	if (deviceModel != null) {
	index = findDescriptorIndexForProduct(deviceArtDescriptors, deviceModel);
	}

	if (index < 0) {
	// Assume that if the min resolution is > 1280, then we are on a tablet
	String defaultDevice = Math.min(image.getWidth(), image.getHeight()) > 1280 ? "Generic Tablet" : "Generic Phone";
	index = findDescriptorIndexForProduct(deviceArtDescriptors, defaultDevice);
	}

	// If we can't find anything (which shouldn't happen since we should get the Generic Phone/Tablet),
	// default to the first one.
	if (index < 0) {
	index = 0;
	}

	return index;
	}

	private static int findDescriptorIndexForProduct(List<DeviceArtDescriptor> descriptors, String deviceModel) {
	for (int i = 0; i < descriptors.size(); i++) {
	DeviceArtDescriptor d = descriptors.get(i);
	if (d.getName().equalsIgnoreCase(deviceModel)) {
	return i;
	}
	}
	return -1;
	}

	@Override
	protected void dispose() {
	myProvider.disposeEditor(myImageFileEditor);
	super.dispose();
	}

	private void doRefreshScreenshot() {
	assert myDevice != null;
	new ScreenshotTask(myProject, myDevice) {
	@Override
	public void onSuccess() {
	String msg = getError();
	if (msg != null) {
	Messages.showErrorDialog(myProject, msg, AndroidBundle.message("android.ddms.actions.screenshot"));
	return;
	}

	BufferedImage image = getScreenshot();
	mySourceImageRef.set(image);
	processScreenshot(myFrameScreenshotCheckBox.isSelected(), myRotationAngle);
	}
	}.queue();
	}

	private void doRotateScreenshot() {
	myRotationAngle = (myRotationAngle + 90) % 360;
	processScreenshot(myFrameScreenshotCheckBox.isSelected(), 90);
	}

	private void doFrameScreenshot() {
	boolean shouldFrame = myFrameScreenshotCheckBox.isSelected();

	myDeviceArtCombo.setEnabled(shouldFrame);
	myDropShadowCheckBox.setEnabled(shouldFrame);
	myScreenGlareCheckBox.setEnabled(shouldFrame);

	if (shouldFrame) {
	processScreenshot(true, 0);
	} else {
	myDisplayedImageRef.set(mySourceImageRef.get());
	updateEditorImage();
	}
	}

	private void processScreenshot(boolean addFrame, int rotateByAngle) {
	DeviceArtDescriptor spec = addFrame ? myDeviceArtDescriptors.get(myDeviceArtCombo.getSelectedIndex()) : null;
	boolean shadow = addFrame && myDropShadowCheckBox.isSelected();
	boolean reflection = addFrame && myScreenGlareCheckBox.isSelected();

	new ImageProcessorTask(myProject, mySourceImageRef.get(), rotateByAngle, spec, shadow, reflection, myBackingVirtualFile) {
	@Override
	public void onSuccess() {
	mySourceImageRef.set(getRotatedImage());
	myDisplayedImageRef.set(getProcessedImage());
	updateEditorImage();
	}
	}.queue();
	}

	private static class ImageProcessorTask extends Task.Modal {
	private final BufferedImage mySrcImage;
	private final int myRotationAngle;
	private final DeviceArtDescriptor myDescriptor;
	private final boolean myAddShadow;
	private final boolean myAddReflection;
	private final VirtualFile myDestinationFile;

	private BufferedImage myRotatedImage;
	private BufferedImage myProcessedImage;

	public ImageProcessorTask(@Nullable Project project,
	@NotNull BufferedImage srcImage,
	int rotateByAngle,
	@Nullable DeviceArtDescriptor descriptor,
	boolean addShadow,
	boolean addReflection,
	VirtualFile writeToFile) {
	super(project, AndroidBundle.message("android.ddms.screenshot.image.processor.task.title"), false);

	mySrcImage = srcImage;
	myRotationAngle = rotateByAngle;
	myDescriptor = descriptor;
	myAddShadow = addShadow;
	myAddReflection = addReflection;
	myDestinationFile = writeToFile;
	}

	@Override
	public void run(@NotNull ProgressIndicator indicator) {
	if (myRotationAngle != 0) {
	myRotatedImage = ImageUtils.rotateByRightAngle(mySrcImage, myRotationAngle);
	} else {
	myRotatedImage = mySrcImage;
	}

	if (myDescriptor != null) {
	myProcessedImage = DeviceArtPainter.createFrame(myRotatedImage, myDescriptor, myAddShadow, myAddReflection);
	} else {
	myProcessedImage = myRotatedImage;
	}

	myProcessedImage = ImageUtils.cropBlank(myProcessedImage, null);

	// update backing file, this is necessary for operations that read the backing file from the editor,
	// such as: Right click image -> Open in external editor
	if (myDestinationFile != null) {
	File file = VfsUtilCore.virtualToIoFile(myDestinationFile);
	try {
	ImageIO.write(myProcessedImage, SdkConstants.EXT_PNG, file);
	}
	catch (IOException e) {
	Logger.getInstance(ImageProcessorTask.class).error("Unexpected error while writing to backing file", e);
	}
	}
	}

	protected BufferedImage getProcessedImage() {
	return myProcessedImage;
	}

	protected BufferedImage getRotatedImage() {
	return myRotatedImage;
	}
	}

	private void updateEditorImage() {
	BufferedImage image = myDisplayedImageRef.get();
	ImageEditor imageEditor = myImageFileEditor.getImageEditor();

	ImageZoomModel zoomModel = imageEditor.getZoomModel();
	double zoom = zoomModel.getZoomFactor();

	imageEditor.getDocument().setValue(image);
	pack();

	zoomModel.setZoomFactor(zoom);
	}

	private FileEditorProvider getImageFileEditorProvider() {
	FileEditorProvider[] providers = FileEditorProviderManager.getInstance().getProviders(myProject, myBackingVirtualFile);
	assert providers.length > 0;

	// Note: In case there are multiple providers for image files, we'd prefer to get the bundled
	// image editor, but we don't have access to any of its implementation details so we rely
	// on the editor type id being "images" as defined by ImageFileEditorProvider#EDITOR_TYPE_ID.
	for (FileEditorProvider p : providers) {
	if (p.getEditorTypeId().equals("images")) {
	return p;
	}
	}

	return providers[0];
	}

	@Nullable
	@Override
	protected JComponent createCenterPanel() {
	return myPanel;
	}

	@NonNls
	@Override
	@Nullable
	protected String getDimensionServiceKey() {
	return SCREENSHOT_VIEWER_DIMENSIONS_KEY;
	}

	@Nullable
	@Override
	public Object getData(@NonNls String dataId) {
	// This is required since the Image Editor's actions are dependent on the context
	// being a ImageFileEditor.
	return PlatformDataKeys.FILE_EDITOR.getName().equals(dataId) ? myImageFileEditor : null;
	}

	@Override
	protected void createDefaultActions() {
	super.createDefaultActions();
	getOKAction().putValue(Action.NAME, AndroidBundle.message("android.ddms.screenshot.save.ok.button.text"));
	}

	@Override
	protected void doOKAction() {
	FileSaverDescriptor descriptor =
	new FileSaverDescriptor(AndroidBundle.message("android.ddms.screenshot.save.title"), "", SdkConstants.EXT_PNG);
	FileSaverDialog saveFileDialog = FileChooserFactory.getInstance().createSaveFileDialog(descriptor, myProject);
	VirtualFile baseDir = ourLastSavedFolder != null ? ourLastSavedFolder : myProject.getBaseDir();
	VirtualFileWrapper fileWrapper = saveFileDialog.save(baseDir, getDefaultFileName());
	if (fileWrapper == null) {
	return;
	}

	myScreenshotFile = fileWrapper.getFile();
	try {
	ImageIO.write(myDisplayedImageRef.get(), SdkConstants.EXT_PNG, myScreenshotFile);
	}
	catch (IOException e) {
	Messages.showErrorDialog(myProject,
	AndroidBundle.message("android.ddms.screenshot.save.error", e),
	AndroidBundle.message("android.ddms.actions.screenshot"));
	return;
	}

	VirtualFile virtualFile = fileWrapper.getVirtualFile();
	if (virtualFile != null) {
	//noinspection AssignmentToStaticFieldFromInstanceMethod
	ourLastSavedFolder = virtualFile.getParent();
	}

	super.doOKAction();
	}

	private String getDefaultFileName() {
	Calendar now = Calendar.getInstance();
	return String.format("%s-%tF-%tH%tM%tS.png", myDevice != null ? "device" : "layout", now, now, now, now);
	}

	public File getScreenshot() {
	return myScreenshotFile;
	}
	}