Attachment #83155 for bug #195691




import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.graphics.Region;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.ColorDialog;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;


	private Button fitButton;

	private Button cropButton;

	private Button markButton;

	private Button colorButton;

	private Image colorIcon;

	private Color markColor;

	private Button resetButton;

	/**
	 * Original screenshot image; used for backup purposes
	 */
	private Image originalImage;

	/**
	 * Copy of {@link #originalImage original} image; all drawing operations are done here; base for the result image
	 */
	private Image workImage;

	/**
	 * Used to draw into {@link #workImage}
	 */
	private GC workImageGC;

	private Canvas canvas;


	private Rectangle originalSelection;

	/**
	 * Temporary storage for selection start point, selection resizing initial reference point or previous mark point
	 * (it depends on current tool); this value is normalized to real image coordinates, no matter the zoom level (see
	 * {@link #scaleFactor})
	 */
	private Point startPoint;


	 */
	private static enum Action {

		IDLE, SELECTING, RESIZING_SELECTION, MOVING_SELECTION, MARKING;

	};


	}

	public void createControl(Composite parent) {

		Composite composite = new Composite(parent, SWT.NONE);
		composite.setLayout(new GridLayout());
		setControl(composite);

		allocateCursors();

		Composite buttonsComposite = new Composite(composite, SWT.NONE);
		buttonsComposite.setLayout(new GridLayout(6, false));
		captureButton = new Button(buttonsComposite, SWT.PUSH);
		captureButton.setText("&Capture Desktop");
		captureButton.setImage(TasksUiImages.getImage(TasksUiImages.IMAGE_CAPTURE));
		captureButton.addSelectionListener(new SelectionAdapter() {

			private boolean isFirstCapture = true;

			public void widgetSelected(SelectionEvent e) {
				captureScreenshotContent();
				page.setErrorMessage(null);
				if (isFirstCapture) {
					isFirstCapture = false;
					fitButton.setEnabled(true);
					cropButton.setEnabled(true);
					cropButton.setSelection(true);
					markButton.setEnabled(true);
					resetButton.setEnabled(true);
				}
			}

		});

//		});

		fitButton = new Button(buttonsComposite, SWT.TOGGLE);
		fitButton.setText("&Fit Image");
		fitButton.setImage(TasksUiImages.getImage(TasksUiImages.IMAGE_FIT));
		fitButton.addSelectionListener(new SelectionAdapter() {


		fitButton.setSelection(true);
		fitButton.setEnabled(false);

		cropButton = new Button(buttonsComposite, SWT.TOGGLE);
		cropButton.setText("Cro&p");
		cropButton.addSelectionListener(new SelectionAdapter() {

			@Override
			public void widgetSelected(SelectionEvent e) {
				currentAction = Action.IDLE;
				cropButton.setSelection(true);
				markButton.setSelection(false);
				colorButton.setEnabled(false);
				canvas.redraw();
			}

		});
		cropButton.setEnabled(false);

		markButton = new Button(buttonsComposite, SWT.TOGGLE);
		markButton.setText("&Mark");
		markButton.addSelectionListener(new SelectionAdapter() {

			@Override
			public void widgetSelected(SelectionEvent e) {
				currentAction = Action.MARKING;
				cropButton.setSelection(false);
				markButton.setSelection(true);
				colorButton.setEnabled(true);
				canvas.redraw();
			}

		});
		markButton.setEnabled(false);

		colorButton = new Button(buttonsComposite, SWT.PUSH);
		colorButton.setText("Change Co&lor...");
		colorIcon = new Image(Display.getCurrent(), 16, 16);
		setMarkColor(new RGB(255, 0, 0));
		colorButton.setEnabled(false);
		colorButton.addSelectionListener(new SelectionAdapter() {

			@Override
			public void widgetSelected(SelectionEvent e) {
				ColorDialog dialog = new ColorDialog(getControl().getShell());
				RGB color = dialog.open();
				if (color != null) {
					setMarkColor(color);
				}
			}

		});

		resetButton = new Button(buttonsComposite, SWT.PUSH);
		resetButton.setText("&Reset Image");
		resetButton.addSelectionListener(new SelectionAdapter() {

			@Override
			public void widgetSelected(SelectionEvent e) {
				workImageGC.drawImage(originalImage, 0, 0);
				canvas.redraw();
			}

		});
		resetButton.setEnabled(false);

		scrolledComposite = new ScrolledComposite(composite, SWT.V_SCROLL | SWT.H_SCROLL | SWT.BORDER);
		scrolledComposite.setLayoutData(GridDataFactory.fillDefaults()
				.align(SWT.FILL, SWT.FILL)

		canvas.addPaintListener(new PaintListener() {

			public void paintControl(PaintEvent e) {
				if (workImage != null) {
					Rectangle imageBounds = workImage.getBounds();
					Rectangle canvasBounds = canvas.getClientArea();

					if (fitButton.getSelection()) {
						e.gc.drawImage(workImage, 0, 0, imageBounds.width, imageBounds.height, 0, 0,
								canvasBounds.width, canvasBounds.height);
					} else {
						e.gc.drawImage(workImage, 0, 0);
					}

					if (currentAction == Action.IDLE) {

							drawSelection(e.gc);
						}
					} else if (currentAction == Action.SELECTING || currentAction == Action.RESIZING_SELECTION
							|| currentAction == Action.MOVING_SELECTION || currentAction == Action.MARKING) {
						if (currentSelection != null) {
							drawSelectionPreview(e.gc);
						}

		registerMouseListeners();
	}

	private void setMarkColor(RGB color) {
		if (markColor != null) {
			markColor.dispose();
		}
		markColor = new Color(Display.getCurrent(), color);
		if (workImageGC != null) {
			workImageGC.setForeground(markColor);
		}

		GC colorGC = new GC(colorIcon);
		colorGC.setBackground(markColor);
		colorGC.fillRectangle(0, 0, 15, 15);
		colorGC.drawRectangle(0, 0, 15, 15);
		colorGC.dispose();

		colorButton.setImage(colorIcon);
	}

	@Override
	public void dispose() {
		disposeImageResources();
		if (markColor != null) {
			markColor.dispose();
		}
		if (colorIcon != null) {
			colorIcon.dispose();
		}

		canvas.setCursor(null);
		for (Cursor cursor : cursors.values()) {
			cursor.dispose();

		super.dispose();
	}

	private void disposeImageResources() {
		if (originalImage != null) {
			originalImage.dispose();
		}
		if (workImageGC != null) {
			workImageGC.dispose();
		}
		if (workImage != null) {
			workImage.dispose();
		}
	}

	private static final int CURSOR_MARK_TOOL = -1;

	private void allocateCursors() {
		Display display = Display.getCurrent();
		cursors.put(SWT.CURSOR_ARROW, new Cursor(display, SWT.CURSOR_ARROW));

		cursors.put(SWT.CURSOR_SIZENS, new Cursor(display, SWT.CURSOR_SIZENS));
		cursors.put(SWT.CURSOR_SIZEWE, new Cursor(display, SWT.CURSOR_SIZEWE));
		cursors.put(SWT.CURSOR_CROSS, new Cursor(display, SWT.CURSOR_CROSS));

		// TODO: allocate custom cursor for "mark" tool
		cursors.put(CURSOR_MARK_TOOL, new Cursor(display, SWT.CURSOR_HAND));
	}

	private Rectangle getScaledSelection() {

		int y = (int) Math.round(currentSelection.y * scaleFactor);
		int right = (int) Math.round((currentSelection.x + currentSelection.width) * scaleFactor);
		int bottom = (int) Math.round((currentSelection.y + currentSelection.height) * scaleFactor);
		int width = Math.min(right, (int) Math.round((workImage.getBounds().width - 1) * scaleFactor)) - x;
		int height = Math.min(bottom, (int) Math.round((workImage.getBounds().height - 1) * scaleFactor)) - y;
		return new Rectangle(x, y, width, height);
	}

	@Override
	public boolean isPageComplete() {
		return workImage != null;
			return false;
		return true;
	}

	@Override

		attachment.setContentType("image/jpeg");
		page.setFilePath(InputAttachmentSourcePage.SCREENSHOT_LABEL);
		page.setContentType();
		getCropScreenshot();
		return page;
	}


	}

	private void captureScreenshotContent() {
		Display display = Display.getDefault();
		Shell wizardShell = getWizard().getContainer().getShell();
		final Shell wizardShell = getWizard().getContainer().getShell();
		wizardShell.setVisible(false);

		// NOTE: need a wait since the shell can take time to disappear (e.g. fade on Vista)

			// ignore
		}

		disposeImageResources();
		Rectangle displayBounds = display.getBounds();
		originalImage = new Image(display, displayBounds);
		workImage = new Image(display, displayBounds);

		GC gc = new GC(display);
		gc.copyArea(originalImage, 0, 0);
		gc.copyArea(workImage, 0, 0);
		gc.dispose();

		workImageGC = new GC(workImage);
		workImageGC.setForeground(markColor);
		workImageGC.setLineWidth(4);
		workImageGC.setLineCap(SWT.CAP_ROUND);

		clearSelection();
		refreshCanvasSize();

		wizardShell.setVisible(true);
		setPageComplete(true);
		});
	}

	/**

		currentSelection = new Rectangle(startX, startY, width, height);

		// Decreases 1 pixel size from original image because Rectangle.intersect() consider them as right-bottom limit
		Rectangle imageBounds = workImage.getBounds();
		imageBounds.width--;
		imageBounds.height--;
		currentSelection.intersect(imageBounds);

			return;
		}

		canvas.setCursor(null);
		grabPoints.clear();
		Rectangle scaledSelection = getScaledSelection();
		grabPoints.add(GrabPoint.createGrabPoint(scaledSelection.x, scaledSelection.y, SWT.CURSOR_SIZENWSE, EnumSet.of(

				originalSelection.height);
		int deltaX = x - startPoint.x;
		int deltaY = y - startPoint.y;
		Rectangle imageBounds = workImage.getBounds();

		// Check current selection limits
		if (resizableSides.contains(SelectionSide.LEFT)) {

		if (newY < 0) {
			newY = 0;
		}
		Rectangle imageBounds = workImage.getBounds();
		if (newX + originalSelection.width - 1 > imageBounds.width) {
			newX = imageBounds.width - originalSelection.width;
		}

			 * If a selection is in course, moving the mouse around refreshes the selection rectangle
			 */
			public void mouseMove(MouseEvent e) {
				int scaledX = (int) Math.round(e.x / scaleFactor);
				int scaledY = (int) Math.round(e.y / scaleFactor);

				if (currentAction == Action.SELECTING) {
					refreshCurrentSelection(scaledX, scaledY);
					refreshCurrentSelection((int) Math.round(e.x / scaleFactor), (int) Math.round(e.y / scaleFactor));
					canvas.redraw();
				} else if (currentAction == Action.RESIZING_SELECTION) {
					refreshSelectionResize(scaledX, scaledY);
					canvas.redraw();
				} else if (currentAction == Action.MOVING_SELECTION) {
					refreshSelectionPosition(scaledX, scaledY);
					canvas.redraw();
				} else if (currentAction == Action.IDLE && currentSelection != null) {
					boolean cursorSet = false;

						canvas.setCursor(cursors.get(SWT.CURSOR_SIZEALL));
						cursorSet = true;
					}

					// If I'm out, the default cursor for cropping mode is cross
					Cursor crossCursor = cursors.get(SWT.CURSOR_CROSS);
					if (!cursorSet && canvas.getCursor() != crossCursor) {
						canvas.setCursor(crossCursor);
					}
				} else if (currentAction == Action.MARKING) {
					drawMarkLine(scaledX, scaledY);

					Cursor markCursor = cursors.get(CURSOR_MARK_TOOL);
					if (canvas.getCursor() != markCursor) {
						canvas.setCursor(markCursor);
					}
				}
			}

			public void mouseUp(MouseEvent e) {
				if (currentAction == Action.SELECTING || currentAction == Action.RESIZING_SELECTION
						|| currentAction == Action.MOVING_SELECTION) {
					canvas.setCursor(cursors.get(SWT.CURSOR_ARROW));

					int scaledX = (int) Math.round(e.x / scaleFactor);
					int scaledY = (int) Math.round(e.y / scaleFactor);
					if (currentAction == Action.SELECTING) {

					currentAction = Action.IDLE;

					canvas.redraw();
				} else if (currentAction == Action.MARKING) {
					startPoint = null;
				}
			}


			 * Pressing mouse button starts a selection; normalizes and marks the start point
			 */
			public void mouseDown(MouseEvent e) {
				int scaledX = (int) (e.x / scaleFactor);
				int scaledY = (int) (e.y / scaleFactor);

				if (currentAction == Action.MARKING) {
					startPoint = new Point(scaledX, scaledY);
					drawMarkLine(scaledX, scaledY);
					canvas.setCursor(cursors.get(CURSOR_MARK_TOOL));
					return;
				} else if (currentAction != Action.IDLE) {
					return;
				}


							originalSelection = currentSelection;
							currentAction = Action.RESIZING_SELECTION;
							resizableSides = point.resizableSides;
							startPoint = new Point(scaledX, scaledY);
							canvas.redraw();
							return;
						}

				}

				// Check if I could move the selection
				if (currentSelection != null && currentSelection.contains(scaledX, scaledY)) {
						&& currentSelection.contains((int) (e.x / scaleFactor), (int) (e.y / scaleFactor))) {
					originalSelection = currentSelection;
					currentAction = Action.MOVING_SELECTION;
					startPoint = new Point(scaledX, scaledY);
					canvas.redraw();
					return;
				}

				canvas.setCursor(cursors.get(SWT.CURSOR_CROSS));
				currentAction = Action.SELECTING;
				currentSelection = null;
				startPoint = new Point(scaledX, scaledY);
				canvas.redraw();
			}


	/**
	 * Recalculates image canvas size based on "fit on canvas" setting, set up the grab points, and redraws
	 * <p>
	 * This method should be called whenever the {@link #workImage image} <strong>visible</strong> size is changed,
	 * which can happen when:
	 * <p>
	 * <ul>
	 * <li>The "Fit Image" setting is changed, so the image zoom level changes

			scrolledComposite.getVerticalBar().setVisible(false);

			Rectangle bounds = scrolledComposite.getClientArea();
			if (workImage != null) {
				Rectangle imageBounds = workImage.getBounds();
				if (imageBounds.width > bounds.width || imageBounds.height > bounds.height) {
					double xRatio = (double) bounds.width / imageBounds.width;
					double yRatio = (double) bounds.height / imageBounds.height;

		} else {
			scaleFactor = 1.0;
			Rectangle bounds = scrolledComposite.getClientArea();
			if (workImage != null) {
				Rectangle imageBounds = workImage.getBounds();
				bounds.width = imageBounds.width;
				bounds.height = imageBounds.height;
			}

		}
	}

	/**
	 * Connects the previous mark point to the new reference point, by drawing a new line
	 */
	private void drawMarkLine(int x, int y) {
		if (startPoint != null) {
			workImageGC.drawLine(startPoint.x, startPoint.y, x, y);
			startPoint.x = x;
			startPoint.y = y;
			canvas.redraw();
		}
	}

	private static enum SelectionSide {

		LEFT, RIGHT, TOP, BOTTOM;


	private List<GrabPoint> grabPoints = new ArrayList<GrabPoint>(8);

	/**
	 * Creates the final screenshot
	 * 
	 * @return The final screenshot, with all markings, and cropped according to user settings; <strong>The caller is
	 *         responsible for disposing the returned image</strong>
	 */
	public Image createScreenshotImage() {
		Image screenshot = new Image(Display.getDefault(), currentSelection != null ? currentSelection
				: workImage.getBounds());

		GC gc = new GC(screenshot);
		if (currentSelection != null) {
			gc.drawImage(workImage, currentSelection.x, currentSelection.y, currentSelection.width,
					currentSelection.height, 0, 0, currentSelection.width, currentSelection.height);
		} else {
			gc.drawImage(workImage, 0, 0);
		}

		Image image = new Image(Display.getDefault(), currentSelection);
		GC gc = new GC(image);
		gc.drawImage(screenshotImage, currentSelection.x, currentSelection.y, currentSelection.width,
				currentSelection.height, 0, 0, currentSelection.width, currentSelection.height);
		gc.dispose();

		return screenshot;
	}

	public Image getScreenshotImage() {
		return getCropScreenshot();
	}

}




	private AbstractTask task;

	private boolean screenshotMode;

	public NewAttachmentWizard(TaskRepository repository, AbstractTask task, boolean screenshotMode) {
		super();
		this.task = task;

			setWindowTitle("Add Attachment");
			setDefaultPageImageDescriptor(TasksUiImages.BANNER_REPOSITORY);
		}

		inputPage = new InputAttachmentSourcePage(this);
		attachment = new LocalAttachment();
		attachment.setFilePath("");

	public NewAttachmentWizard(TaskRepository repository, AbstractTask task) {
		this(repository, task, false);
	}

	public NewAttachmentWizard(TaskRepository repository, AbstractTask task, File attachFile) {
		this(repository, task, false);
		attachment.setFilePath(attachFile.getAbsolutePath());

					task.setSynchronizationState(RepositoryTaskSyncState.OUTGOING);

					if (screenshotMode || InputAttachmentSourcePage.SCREENSHOT_LABEL.equals(path)) {
						Image screenshot = shotPage.createScreenshotImage();
						if (screenshot == null) {
							throw new InvocationTargetException(new CoreException(new RepositoryStatus(IStatus.ERROR,
									TasksUiPlugin.ID_PLUGIN, RepositoryStatus.ERROR_INTERNAL, "Screenshot is empty",
									null)));
						}
						String path = TasksUiPlugin.getDefault().getDefaultDataDirectory();
						ImageLoader loader = new ImageLoader();
						loader.data = new ImageData[] { screenshot.getImageData() };
						String fileName = path + "/" + SCREENSHOT_FILENAME;
						loader.save(fileName, SWT.IMAGE_JPEG);
						attachment.setFile(new File(fileName));
						attachment.setFilename(SCREENSHOT_FILENAME);
						screenshot.dispose();
					} else if (InputAttachmentSourcePage.CLIPBOARD_LABEL.equals(path)) {
						String contents = inputPage.getClipboardContents();
						if (contents == null) {

	@Override
	public boolean canFinish() {
		if (screenshotMode) {
			return shotPage.isPageComplete() && attachPage.isPageComplete();
		} else {
			return attachPage.isPageComplete();
		}

Return to bug 195691

Lines 78-84 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/wizards/NewAttachmentWizard.java (-7 / +8 lines)
78	private AbstractTask task;	78	private AbstractTask task;
79		79
80	private boolean screenshotMode;	80	private boolean screenshotMode;
81		81
82	public NewAttachmentWizard(TaskRepository repository, AbstractTask task, boolean screenshotMode) {	82	public NewAttachmentWizard(TaskRepository repository, AbstractTask task, boolean screenshotMode) {
83	super();	83	super();
84	this.task = task;	84	this.task = task;
Lines 92-98 Link Here
92	setWindowTitle("Add Attachment");	92	setWindowTitle("Add Attachment");
93	setDefaultPageImageDescriptor(TasksUiImages.BANNER_REPOSITORY);	93	setDefaultPageImageDescriptor(TasksUiImages.BANNER_REPOSITORY);
94	}	94	}
95		95
96	inputPage = new InputAttachmentSourcePage(this);	96	inputPage = new InputAttachmentSourcePage(this);
97	attachment = new LocalAttachment();	97	attachment = new LocalAttachment();
98	attachment.setFilePath("");	98	attachment.setFilePath("");
Lines 110-116 Link Here
110	public NewAttachmentWizard(TaskRepository repository, AbstractTask task) {	110	public NewAttachmentWizard(TaskRepository repository, AbstractTask task) {
111	this(repository, task, false);	111	this(repository, task, false);
112	}	112	}
113		113
114	public NewAttachmentWizard(TaskRepository repository, AbstractTask task, File attachFile) {	114	public NewAttachmentWizard(TaskRepository repository, AbstractTask task, File attachFile) {
115	this(repository, task, false);	115	this(repository, task, false);
116	attachment.setFilePath(attachFile.getAbsolutePath());	116	attachment.setFilePath(attachFile.getAbsolutePath());
Lines 158-176 Link Here
158	task.setSynchronizationState(RepositoryTaskSyncState.OUTGOING);	158	task.setSynchronizationState(RepositoryTaskSyncState.OUTGOING);
159		159
160	if (screenshotMode \|\| InputAttachmentSourcePage.SCREENSHOT_LABEL.equals(path)) {	160	if (screenshotMode \|\| InputAttachmentSourcePage.SCREENSHOT_LABEL.equals(path)) {
161	Image image = shotPage.getScreenshotImage();	161	Image screenshot = shotPage.createScreenshotImage();
162	if (image == null) {	162	if (screenshot == null) {
163	throw new InvocationTargetException(new CoreException(new RepositoryStatus(IStatus.ERROR,	163	throw new InvocationTargetException(new CoreException(new RepositoryStatus(IStatus.ERROR,
164	TasksUiPlugin.ID_PLUGIN, RepositoryStatus.ERROR_INTERNAL, "Screenshot is empty",	164	TasksUiPlugin.ID_PLUGIN, RepositoryStatus.ERROR_INTERNAL, "Screenshot is empty",
165	null)));	165	null)));
166	}	166	}
167	String path = TasksUiPlugin.getDefault().getDefaultDataDirectory();	167	String path = TasksUiPlugin.getDefault().getDefaultDataDirectory();
168	ImageLoader loader = new ImageLoader();	168	ImageLoader loader = new ImageLoader();
169	loader.data = new ImageData[] { image.getImageData() };	169	loader.data = new ImageData[] { screenshot.getImageData() };
170	String fileName = path + "/" + SCREENSHOT_FILENAME;	170	String fileName = path + "/" + SCREENSHOT_FILENAME;
171	loader.save(fileName, SWT.IMAGE_JPEG);	171	loader.save(fileName, SWT.IMAGE_JPEG);
172	attachment.setFile(new File(fileName));	172	attachment.setFile(new File(fileName));
173	attachment.setFilename(SCREENSHOT_FILENAME);	173	attachment.setFilename(SCREENSHOT_FILENAME);
		174	screenshot.dispose();
174	} else if (InputAttachmentSourcePage.CLIPBOARD_LABEL.equals(path)) {	175	} else if (InputAttachmentSourcePage.CLIPBOARD_LABEL.equals(path)) {
175	String contents = inputPage.getClipboardContents();	176	String contents = inputPage.getClipboardContents();
176	if (contents == null) {	177	if (contents == null) {
Lines 293-299 Link Here
293	@Override	294	@Override
294	public boolean canFinish() {	295	public boolean canFinish() {
295	if (screenshotMode) {	296	if (screenshotMode) {
296	return shotPage.isPageComplete();	297	return shotPage.isPageComplete() && attachPage.isPageComplete();
297	} else {	298	} else {
298	return attachPage.isPageComplete();	299	return attachPage.isPageComplete();
299	}	300	}