Attachment #90227 for bug #195691





	@Override
	public boolean isPageComplete() {
		return !"".equals(filePath.getText().trim())
				&& (attachmentDesc == null || !"".equals(attachmentDesc.getText().trim()));
	}

	public void populateAttachment() {

		return attachment;
	}

	@Override
	public boolean canFlipToNextPage() {
		if (filePath.getText().equals(InputAttachmentSourcePage.SCREENSHOT_LABEL))
			return false;
		return isPageComplete();
	}

	public void setFilePath(String path) {
		filePath.setText(path);
		if (path.endsWith(".patch")) {

	public boolean supportsDescription() {
		return supportsDescription;
	}

	public void setSupportsDescription(boolean supportsDescription) {
		this.supportsDescription = supportsDescription;
	}

}




import org.eclipse.mylyn.tasks.ui.editors.AbstractRepositoryTaskEditorInput;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditorInput;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.ImageLoader;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.PlatformUI;


	private boolean screenshotMode;

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

		}

		inputPage = new InputAttachmentSourcePage(this);
		if (screenshotMode) {
			shotPage = new ScreenshotAttachmentPage();
			attachment = new ImageAttachment(shotPage);
		} else {
			attachment = new LocalAttachment();
		}
		attachment.setFilePath("");
		setNeedsProgressMonitor(true);
		IDialogSettings workbenchSettings = TasksUiPlugin.getDefault().getDialogSettings();

	}

	@Override
	public void dispose() {
		// Ensures the temporary screenshot image is deleted
		if (attachment != null && attachment instanceof ImageAttachment) {
			((ImageAttachment) attachment).clearImageFile();
		}
		super.dispose();
	}

	@Override
	public boolean performFinish() {
		/* TODO jpound - support non-text in clipboard */
		attachPage.populateAttachment();

					task.setSynchronizationState(RepositoryTaskSyncState.OUTGOING);

					if (screenshotMode || InputAttachmentSourcePage.SCREENSHOT_LABEL.equals(path)) {
						((ImageAttachment) attachment).ensureImageFileWasCreated();
						if (image == 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[] { image.getImageData() };
						String fileName = path + "/" + SCREENSHOT_FILENAME;
						loader.save(fileName, SWT.IMAGE_JPEG);
						attachment.setFile(new File(fileName));
						attachment.setFilename(SCREENSHOT_FILENAME);
					} 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();
		}

	public void addPages() {
		super.addPages();
		if (screenshotMode) {
			addPage(shotPage);
			addPage((attachPage = new NewAttachmentPage(attachment)));
		} else {
			if ("".equals(attachment.getFilePath())) {




import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.mylyn.internal.tasks.core.LocalAttachment;
import org.eclipse.swt.SWT;

	private static final String TITLE = "Attachment Preview";

	private static final String DESCRIPTION = "Review the attachment before submitting";

	private LocalAttachment attachment;

	private static HashMap<String, String> textTypes;

		composite.setLayout(new GridLayout());
		setControl(composite);

		if (attachment instanceof ImageAttachment) {
			try {
				getContainer().run(true, false, new IRunnableWithProgress() {
					public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
						monitor.beginTask("Preparing image for preview...", 1);
						((ImageAttachment) attachment).ensureImageFileWasCreated();
						monitor.worked(1);
						monitor.done();
					}
				});
			} catch (InvocationTargetException e) {
				createErrorPreview(composite, "Could not create image for preview");
				return;
			} catch (InterruptedException e) {
				createErrorPreview(composite, "Could not create image for preview");
				return;
			}
		}

		if (InputAttachmentSourcePage.CLIPBOARD_LABEL.equals(attachment.getFilePath())) {
			createTextPreview(composite, ((NewAttachmentWizard) getWizard()).getClipboardContents());
		} else if (PreviewAttachmentPage.isTextAttachment(attachment.getContentType())) {




import java.util.Map;
import java.util.Set;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.wizard.IWizardPage;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.mylyn.internal.tasks.core.LocalAttachment;
import org.eclipse.mylyn.internal.tasks.ui.TaskListColorsAndFonts;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiImages;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.custom.ViewForm;
import org.eclipse.swt.events.ControlAdapter;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.MouseAdapter;

import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.events.SelectionEvent;
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.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.ToolItem;

/**
 * A wizard page to create a screenshot from the display.
 * <p>
 * Note: this class uses {@link GC#setXORMode(boolean)} which is deprecated because of lack of Mac implementation
 * (bug#50228). The strategy to make it work on platforms XOR is implemented and still have a good looking in platforms
 * where it is not implemented, is to draw each line 2 times: first using a WHITE foreground followed by the same draw
 * using a BLACK foreground. On platforms where XOR is implemented, the second draw will have no effect, since anything
 * XOR black results in noop. On platforms where XOR is NOT implemented, the {@link GC#setXORMode(boolean)} is a noop,
 * so the end result will be a black line.
 * 
 * @author Balazs Brinkus (bug 160572)
 * @author Mik Kersten
 * @author Willian Mitsuda
 */
public class ScreenshotAttachmentPage extends WizardPage implements IImageCreator {

	private IAction captureAction;

	private IAction fitAction;

	private IAction cropAction;

	private IAction markAction;

	private IAction colorAction;

	private Image colorIcon;

	private Color markColor;

	private IAction clearAction;

	/**
	 * 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;

	/**
	 * What sides I'm resizing when doing an selection {@link EditorAction#RESIZING_SELECTION resize}
	 */
	private Set<SelectionSide> resizableSides = EnumSet.noneOf(SelectionSide.class);


	/**
	 * Available actions for the screenshot editor
	 */
	private static enum EditorAction {

		CROPPING, SELECTING, RESIZING_SELECTION, MOVING_SELECTION, MARKING;

	};

	/**
	 * What am I doing now?
	 */
	private EditorAction currentAction = EditorAction.CROPPING;

	protected ScreenshotAttachmentPage() {
		super("ScreenShotAttachment");
		setTitle("Capture Screenshot");
		setDescription("After capturing, you can crop the image and make drawings on it. This window will not be captured. "
				+ "Note that you can continue to interact with the workbench in order to set up the screenshot.");
		this.attachment = attachment;
		this.page = this;
	}

	public void createControl(Composite parent) {
		ViewForm vf = new ViewForm(parent, SWT.BORDER | SWT.FLAT);
		vf.horizontalSpacing = 0;
		vf.verticalSpacing = 0;
		setControl(vf);
		vf.setLayoutData(GridDataFactory.fillDefaults().create());

		allocateCursors();

		// TODO: need disabled versions of all toolbar icons
		ToolBarManager tbm = new ToolBarManager(SWT.FLAT | SWT.HORIZONTAL | SWT.RIGHT);
		captureAction = new Action("&Capture Desktop", IAction.AS_PUSH_BUTTON) {

			private boolean isFirstCapture = true;
		captureButton.addSelectionListener(new SelectionAdapter() {

			@Override
			public void run() {
				captureScreenshotContent();
				setErrorMessage(null);
				if (isFirstCapture) {
					isFirstCapture = false;
					fitAction.setEnabled(true);
					cropAction.setEnabled(true);
					cropAction.setChecked(true);
					markAction.setEnabled(true);
					clearAction.setEnabled(false);
				}
			}

		};
		captureAction.setToolTipText("Capture Desktop");
		captureAction.setImageDescriptor(ImageDescriptor.createFromImage(TasksUiImages.getImage(TasksUiImages.IMAGE_CAPTURE)));

//		captureDelayedButton = new Button(buttonsComposite, SWT.PUSH);
//		final String captureIn = "Capture in ";

//			}
//		});

		fitAction = new Action("", IAction.AS_CHECK_BOX) {
			@Override
			public void run() {
		fitButton.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {
				refreshCanvasSize();
			}
		};
		fitAction.setToolTipText("Fit Image");
		fitAction.setText("&Fit Image");
		fitAction.setImageDescriptor(ImageDescriptor.createFromImage(TasksUiImages.getImage(TasksUiImages.IMAGE_FIT)));
		fitAction.setChecked(true);
		fitAction.setEnabled(false);

		cropAction = new Action("C&rop", IAction.AS_RADIO_BUTTON) {
			@Override
			public void run() {
				currentAction = EditorAction.CROPPING;
				cropAction.setChecked(true);
				markAction.setChecked(false);
				colorAction.setEnabled(false);
				canvas.redraw();
			}
		};
		cropAction.setToolTipText("Crop");
		cropAction.setImageDescriptor(ImageDescriptor.createFromFile(getClass(), "crop.png"));
		cropAction.setEnabled(false);

		markAction = new Action("&Annotate", IAction.AS_RADIO_BUTTON) {
			@Override
			public void run() {
				currentAction = EditorAction.MARKING;
				cropAction.setChecked(false);
				markAction.setChecked(true);
				colorAction.setEnabled(true);
				canvas.redraw();
			}
		};
		markAction.setToolTipText("Draw annotations on screenshot image");
		markAction.setImageDescriptor(ImageDescriptor.createFromFile(getClass(), "mark.gif"));
		markAction.setDisabledImageDescriptor(ImageDescriptor.createFromFile(getClass(), "mark_disabled.gif"));
		markAction.setEnabled(false);

		colorAction = new Action("", IAction.AS_DROP_DOWN_MENU) {
			@Override
			public void runWithEvent(final Event e) {
				final ColorSelectionWindow colorWindow = new ColorSelectionWindow(getControl().getShell()) {

					@Override
					protected Point getInitialLocation(Point initialSize) {
						ToolItem toolItem = (ToolItem) e.widget;
						Rectangle itemBounds = toolItem.getBounds();
						Point location = toolItem.getParent().toDisplay(itemBounds.x + itemBounds.width,
								itemBounds.y + itemBounds.height);
						location.x -= initialSize.x;
						return location;
					}

				};
				colorWindow.setBlockOnOpen(true);
				colorWindow.open();
				RGB color = colorWindow.getSelectedRGB();
				if (color != null) {
					setMarkColor(color);
				}
			}
		};
		colorAction.setToolTipText("Change pen color");
		colorIcon = new Image(getShell().getDisplay(), 16, 16);
		setMarkColor(new RGB(255, 85, 85));
		colorAction.setEnabled(false);

		clearAction = new Action("C&lear Annotations", IAction.AS_PUSH_BUTTON) {
			@Override
			public void run() {
				clearAction.setEnabled(false);
				workImageGC.drawImage(originalImage, 0, 0);
				canvas.redraw();
				markAttachmentDirty();
			}
		};
		clearAction.setToolTipText("Clear all annotations made on screenshot image");
		clearAction.setImageDescriptor(ImageDescriptor.createFromFile(getClass(), "erase.png"));
		clearAction.setEnabled(false);

		tbm.add(createAndConfigureCI(captureAction));
		tbm.add(createAndConfigureCI(fitAction));
		tbm.add(new Separator());
		tbm.add(createAndConfigureCI(cropAction));
		tbm.add(createAndConfigureCI(markAction));
		tbm.add(createAndConfigureCI(colorAction));
		tbm.add(new Separator());
		tbm.add(createAndConfigureCI(clearAction));

		scrolledComposite = new ScrolledComposite(vf, SWT.V_SCROLL | SWT.H_SCROLL);
		canvas = new Canvas(scrolledComposite, SWT.DOUBLE_BUFFERED);
		scrolledComposite.setContent(canvas);
		canvas.addPaintListener(new PaintListener() {

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

					if (fitAction.isChecked()) {
						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) {
						if (currentSelection != null) {
							drawSelection(e.gc);
						}
					} else if (currentAction == Action.SELECTING || currentAction == Action.RESIZING_SELECTION
							|| currentAction == Action.MOVING_SELECTION) {
						if (currentSelection != null) {
							drawSelectionPreview(e.gc);
						}
					}
					drawSelection(e.gc);
				} else {
//					page.setErrorMessage("Screenshot required");
					fitAction.setEnabled(false);
				}
			}
		});

		scrolledComposite.addControlListener(new ControlAdapter() {
			@Override
			public void controlResized(ControlEvent e) {
				if (fitAction.isChecked()) {
					refreshCanvasSize();
				}
			}
		});

		vf.setTopLeft(tbm.createControl(vf));
		vf.setContent(scrolledComposite);
		registerMouseListeners();
	}

	private ActionContributionItem createAndConfigureCI(IAction action) {
		ActionContributionItem ci = new ActionContributionItem(action);
		ci.setMode(ActionContributionItem.MODE_FORCE_TEXT);
		return ci;
	}

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

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

		colorAction.setImageDescriptor(ImageDescriptor.createFromImage(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 = getShell().getDisplay();
		cursors.put(SWT.CURSOR_ARROW, new Cursor(display, SWT.CURSOR_ARROW));
		cursors.put(SWT.CURSOR_SIZEALL, new Cursor(display, SWT.CURSOR_SIZEALL));
		cursors.put(SWT.CURSOR_SIZENWSE, new Cursor(display, SWT.CURSOR_SIZENWSE));

		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
	public IWizardPage getNextPage() {
		NewAttachmentPage page = (NewAttachmentPage) getWizard().getPage("AttachmentDetails");
		attachment.setContentType("image/jpeg");
		page.setFilePath(InputAttachmentSourcePage.SCREENSHOT_LABEL);
		page.setContentType();
		getCropScreenshot();
		return page;
	}


	}

	private void captureScreenshotContent() {
		Display display = getShell().getDisplay();
		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);
					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);

	 * level is changed
	 */
	private void setUpGrabPoints() {
		grabPoints.clear();
		if (currentSelection == null) {
			return;
		}

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

				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 (resizableSides.contains(SelectionSide.BOTTOM)) {
			currentSelection.height += deltaY;
		}

		setUpGrabPoints();
	}

	private void refreshSelectionPosition(int x, int y) {

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

			newY = imageBounds.height - originalSelection.height;
		}
		currentSelection = new Rectangle(newX, newY, originalSelection.width, originalSelection.height);

		setUpGrabPoints();
	}

	private void registerMouseListeners() {

			 * 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 == EditorAction.SELECTING) {
					refreshCurrentSelection(scaledX, scaledY);
					canvas.redraw();
				} else if (currentAction == EditorAction.RESIZING_SELECTION) {
					refreshSelectionResize(scaledX, scaledY);
					canvas.redraw();
				} else if (currentAction == EditorAction.MOVING_SELECTION) {
					refreshSelectionPosition(scaledX, scaledY);
					canvas.redraw();
				} else if (currentAction == EditorAction.CROPPING && currentSelection != null) {
					boolean cursorSet = false;

					// No selection in course, but have something selected; first test if I'm hovering some grab point

						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 == EditorAction.MARKING) {
					drawMarkLine(scaledX, scaledY);

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

		canvas.addMouseListener(new MouseAdapter() {

			/**
			 * Releasing the mouse button ends the selection or a drawing; compute the selection rectangle and redraw
			 * the cropped image
			 */
			public void mouseUp(MouseEvent e) {
				if (currentAction == EditorAction.SELECTING || currentAction == EditorAction.RESIZING_SELECTION
						|| currentAction == EditorAction.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 == EditorAction.SELECTING) {
						refreshCurrentSelection(scaledX, scaledY);
					} else if (currentAction == EditorAction.RESIZING_SELECTION) {
						refreshSelectionResize(scaledX, scaledY);
					} else if (currentAction == EditorAction.MOVING_SELECTION) {
						refreshSelectionPosition(scaledX, scaledY);
					}
					if (currentSelection.width == 0 && currentSelection.height == 0) {

					}
					setUpGrabPoints();
					startPoint = null;
					currentAction = EditorAction.CROPPING;

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

			/**
			 * Pressing mouse button starts a selection or a drawing; 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 == EditorAction.MARKING) {
					startPoint = new Point(scaledX, scaledY);
					drawMarkLine(scaledX, scaledY);
					canvas.setCursor(cursors.get(CURSOR_MARK_TOOL));
					return;
				} else if (currentAction != EditorAction.CROPPING) {
					return;
				}


					for (GrabPoint point : grabPoints) {
						if (point.grabArea.contains(e.x, e.y)) {
							originalSelection = currentSelection;
							currentAction = EditorAction.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 = EditorAction.MOVING_SELECTION;
					startPoint = new Point(scaledX, scaledY);
					canvas.redraw();
					return;
				}

				// Do a simple selection
				canvas.setCursor(cursors.get(SWT.CURSOR_CROSS));
				currentAction = EditorAction.SELECTING;
				currentSelection = null;
				startPoint = new Point(scaledX, scaledY);
				setUpGrabPoints();
				canvas.redraw();
			}


	private void clearSelection() {
		currentSelection = null;
		startPoint = null;
		markAttachmentDirty();
	}

	/**
	 * 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

	 * Calling this method under other circumstances may lead to strange behavior in the scrolled composite
	 */
	private void refreshCanvasSize() {
		if (fitAction.isChecked()) {
			// This little hack is necessary to get the client area without scrollbars; 
			// they'll be automatically restored if necessary after Canvas.setBounds()
			scrolledComposite.getHorizontalBar().setVisible(false);
			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;
			}

	}

	/**
	 * Decorates the screenshot canvas with the selection rectangle; this is done while still selecting, so it does not
	 * have all adornments of a {@link #drawSelection(GC) finished} selection
	 */
	@SuppressWarnings("deprecation")
	private void drawSelectionPreview(GC gc) {
		gc.setLineDash(new int[] { 4 });
		gc.setXORMode(true);
		gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_WHITE));
		gc.drawRectangle(getScaledSelection());
		gc.setForeground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));
		gc.drawRectangle(getScaledSelection());
		gc.setXORMode(false);
		gc.setLineStyle(SWT.LINE_SOLID);
	}

	/**
	 * Decorates the screenshot canvas with the selection rectangle, resize grab points and other adornments
	 */
	private void drawSelection(GC gc) {
		if (currentSelection == null) {
			return;
		}
		Rectangle scaledSelection = getScaledSelection();

		// Draw shadow


		// Draw selection rectangle
		gc.setLineStyle(SWT.LINE_SOLID);
		gc.setForeground(getShell().getDisplay().getSystemColor(SWT.COLOR_DARK_GRAY));
		gc.drawRectangle(scaledSelection);

		// Draw grab points
		gc.setBackground(getShell().getDisplay().getSystemColor(SWT.COLOR_WHITE));
		gc.setForeground(getShell().getDisplay().getSystemColor(SWT.COLOR_BLACK));
		for (GrabPoint point : grabPoints) {
			gc.fillRectangle(point.grabArea);
			gc.drawRectangle(point.grabArea);
		}
	}

	/**
	 * 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) {
			clearAction.setEnabled(true);
			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 createImage() {
		Image screenshot = new Image(getShell().getDisplay(), 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;
	}

	private void markAttachmentDirty() {
		NewAttachmentWizard wizard = (NewAttachmentWizard) getWizard();
		((ImageAttachment) wizard.getAttachment()).markDirty();
	}

}




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.wizards;

import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.ShellAdapter;
import org.eclipse.swt.events.ShellEvent;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Shell;

/**
 * Popup window for color selection
 * 
 * @author Willian Mitsuda
 */
public class ColorSelectionWindow extends Window {

	private ColorCanvas[] colors;

	public ColorSelectionWindow(Shell shell) {
		super(shell);
		setShellStyle(SWT.BORDER);
	}

	@Override
	protected void configureShell(Shell newShell) {
		super.configureShell(newShell);
		newShell.addShellListener(new ShellAdapter() {

			@Override
			public void shellDeactivated(ShellEvent e) {
				close();
			}

		});
	}

	@Override
	protected Control createContents(Composite parent) {
		Composite colorComposite = new Composite(parent, SWT.NONE);
		colorComposite.setBackground(getShell().getDisplay().getSystemColor(SWT.COLOR_BLACK));
		colorComposite.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).create());
		colorComposite.setLayout(GridLayoutFactory.fillDefaults().numColumns(8).spacing(1, 1).margins(1, 1).equalWidth(
				true).create());

		// EGA classic palette
		colors = new ColorCanvas[16];
		colors[0] = createColorCanvas(colorComposite, new RGB(0, 0, 0));
		colors[1] = createColorCanvas(colorComposite, new RGB(0, 0, 170));
		colors[2] = createColorCanvas(colorComposite, new RGB(0, 170, 0));
		colors[3] = createColorCanvas(colorComposite, new RGB(0, 170, 170));
		colors[4] = createColorCanvas(colorComposite, new RGB(170, 0, 0));
		colors[5] = createColorCanvas(colorComposite, new RGB(170, 0, 170));
		colors[6] = createColorCanvas(colorComposite, new RGB(170, 85, 0));
		colors[7] = createColorCanvas(colorComposite, new RGB(170, 170, 170));
		colors[8] = createColorCanvas(colorComposite, new RGB(85, 85, 85));
		colors[9] = createColorCanvas(colorComposite, new RGB(85, 85, 255));
		colors[10] = createColorCanvas(colorComposite, new RGB(85, 255, 85));
		colors[11] = createColorCanvas(colorComposite, new RGB(85, 255, 255));
		colors[12] = createColorCanvas(colorComposite, new RGB(255, 85, 85));
		colors[13] = createColorCanvas(colorComposite, new RGB(255, 85, 255));
		colors[14] = createColorCanvas(colorComposite, new RGB(255, 255, 85));
		colors[15] = createColorCanvas(colorComposite, new RGB(255, 255, 255));

		Button closeButton = new Button(parent, SWT.PUSH);
		closeButton.setText("&Close");
		closeButton.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).create());
		closeButton.addSelectionListener(new SelectionAdapter() {

			@Override
			public void widgetSelected(SelectionEvent e) {
				close();
			}

		});
		return parent;
	}

	private ColorCanvas createColorCanvas(Composite parent, RGB rgb) {
		final ColorCanvas canvas = new ColorCanvas(parent, SWT.NONE, rgb);
		canvas.setLayoutData(GridDataFactory.fillDefaults().hint(16, 16).create());
		canvas.addMouseListener(new MouseAdapter() {

			@Override
			public void mouseDown(MouseEvent e) {
				selectedRGB = canvas.getRGB();
				close();
			}

		});
		return canvas;
	}

	private RGB selectedRGB;

	public RGB getSelectedRGB() {
		return selectedRGB;
	}

}




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.wizards;

import java.io.File;

import org.eclipse.mylyn.internal.tasks.core.LocalAttachment;
import org.eclipse.mylyn.tasks.ui.TasksUiPlugin;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.ImageLoader;

/**
 * Represents a attachment created from a {@link Image}; handles lazy persistence into a {@link File} and image data
 * change
 * 
 * @author Willian Mitsuda
 */
public class ImageAttachment extends LocalAttachment {

	private static final long serialVersionUID = 28264291629999181L;

	/**
	 * Provides the {@link Image} object that will be converted to desired file format, and then attached
	 */
	private IImageCreator imageCreator;

	public ImageAttachment(IImageCreator imageCreator) {
		this.imageCreator = imageCreator;
	}

	@Override
	public void setContentType(String contentType) {
		// Does not apply; actually always save as JPEG
		// Will be implemented on bug#210179
	}

	@Override
	public String getContentType() {
		return "image/jpeg";
	}

	@Override
	public String getFilename() {
		return "screenshot.jpg";
	}

	private boolean dirty = true;

	public void markDirty() {
		dirty = true;
	}

	public void ensureImageFileWasCreated() {
		if (!dirty) {
			return;
		}

		dirty = false;
		createContents();
	}

	private void createContents() {
		Image image = imageCreator.createImage();
		try {
			String path = TasksUiPlugin.getDefault().getDefaultDataDirectory();
			ImageLoader loader = new ImageLoader();
			loader.data = new ImageData[] { image.getImageData() };
			String fileName = path + "/" + getFilename();
			loader.save(fileName, SWT.IMAGE_JPEG);
			setFile(new File(fileName));
			setFilePath(fileName);
		} finally {
			image.dispose();
		}
	}

	public void clearImageFile() {
		String path = TasksUiPlugin.getDefault().getDefaultDataDirectory();
		new File(path + "/" + getFilename()).delete();
	}

}




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.wizards;

import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;

/**
 * A tiny control just for color display
 * 
 * @author Willian Mitsuda
 */
public class ColorCanvas extends Canvas {

	private Color color;

	public ColorCanvas(Composite parent, int style, RGB rgb) {
		super(parent, style);
		color = new Color(parent.getDisplay(), rgb);
		addPaintListener(new PaintListener() {
			public void paintControl(PaintEvent e) {
				e.gc.setBackground(color);
				e.gc.fillRectangle(getClientArea());
			}
		});
		addDisposeListener(new DisposeListener() {
			public void widgetDisposed(DisposeEvent e) {
				color.dispose();
			}
		});
	}

	public RGB getRGB() {
		return color.getRGB();
	}

}




/*******************************************************************************
 * Copyright (c) 2004, 2007 Mylyn project committers and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *******************************************************************************/

package org.eclipse.mylyn.internal.tasks.ui.wizards;

import org.eclipse.swt.graphics.Image;

/**
 * Something capable of creating {@link Image images}
 * 
 * @author Willian Mitsuda
 */
public interface IImageCreator {

	/**
	 * Creates a {@link Image} object it represents; the caller is responsible for disposing the returned {@link Image}
	 */
	public Image createImage();

}

Return to bug 195691

Lines 239-245 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/wizards/NewAttachmentPage.java (-10 / +4 lines)
239		239
240	@Override	240	@Override
241	public boolean isPageComplete() {	241	public boolean isPageComplete() {
242	return !"".equals(filePath.getText().trim()) && (attachmentDesc == null \|\| !"".equals(attachmentDesc.getText().trim()));	242	return !"".equals(filePath.getText().trim())
		243	&& (attachmentDesc == null \|\| !"".equals(attachmentDesc.getText().trim()));
243	}	244	}
244		245
245	public void populateAttachment() {	246	public void populateAttachment() {
Lines 253-265 Link Here
253	return attachment;	254	return attachment;
254	}	255	}
255		256
256	@Override
257	public boolean canFlipToNextPage() {
258	if (filePath.getText().equals(InputAttachmentSourcePage.SCREENSHOT_LABEL))
259	return false;
260	return isPageComplete();
261	}
262
263	public void setFilePath(String path) {	257	public void setFilePath(String path) {
264	filePath.setText(path);	258	filePath.setText(path);
265	if (path.endsWith(".patch")) {	259	if (path.endsWith(".patch")) {
Lines 298-306 Link Here
298	public boolean supportsDescription() {	292	public boolean supportsDescription() {
299	return supportsDescription;	293	return supportsDescription;
300	}	294	}
301		295
302	public void setSupportsDescription(boolean supportsDescription) {	296	public void setSupportsDescription(boolean supportsDescription) {
303	this.supportsDescription = supportsDescription;	297	this.supportsDescription = supportsDescription;
304	}	298	}
305		299
306	}	300	}

Lines 42-51 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/wizards/NewAttachmentWizard.java (-21 / +18 lines)
42	import org.eclipse.mylyn.tasks.ui.editors.AbstractRepositoryTaskEditorInput;	42	import org.eclipse.mylyn.tasks.ui.editors.AbstractRepositoryTaskEditorInput;
43	import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;	43	import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;
44	import org.eclipse.mylyn.tasks.ui.editors.TaskEditorInput;	44	import org.eclipse.mylyn.tasks.ui.editors.TaskEditorInput;
45	import org.eclipse.swt.SWT;
46	import org.eclipse.swt.graphics.Image;
47	import org.eclipse.swt.graphics.ImageData;
48	import org.eclipse.swt.graphics.ImageLoader;
49	import org.eclipse.swt.widgets.Display;	45	import org.eclipse.swt.widgets.Display;
50	import org.eclipse.ui.PlatformUI;	46	import org.eclipse.ui.PlatformUI;
51		47
Lines 81-87 Link Here
81	private boolean screenshotMode;	77	private boolean screenshotMode;
82		78
83	public NewAttachmentWizard(TaskRepository repository, AbstractTask task, boolean screenshotMode) {	79	public NewAttachmentWizard(TaskRepository repository, AbstractTask task, boolean screenshotMode) {
84	super();
85	this.task = task;	80	this.task = task;
86	this.repository = repository;	81	this.repository = repository;
87	this.screenshotMode = screenshotMode;	82	this.screenshotMode = screenshotMode;
Lines 95-101 Link Here
95	}	90	}
96		91
97	inputPage = new InputAttachmentSourcePage(this);	92	inputPage = new InputAttachmentSourcePage(this);
98	attachment = new LocalAttachment();	93	if (screenshotMode) {
		94	shotPage = new ScreenshotAttachmentPage();
		95	attachment = new ImageAttachment(shotPage);
		96	} else {
		97	attachment = new LocalAttachment();
		98	}
99	attachment.setFilePath("");	99	attachment.setFilePath("");
100	setNeedsProgressMonitor(true);	100	setNeedsProgressMonitor(true);
101	IDialogSettings workbenchSettings = TasksUiPlugin.getDefault().getDialogSettings();	101	IDialogSettings workbenchSettings = TasksUiPlugin.getDefault().getDialogSettings();
Lines 125-130 Link Here
125	}	125	}
126		126
127	@Override	127	@Override
		128	public void dispose() {
		129	// Ensures the temporary screenshot image is deleted
		130	if (attachment != null && attachment instanceof ImageAttachment) {
		131	((ImageAttachment) attachment).clearImageFile();
		132	}
		133	super.dispose();
		134	}
		135
		136	@Override
128	public boolean performFinish() {	137	public boolean performFinish() {
129	/* TODO jpound - support non-text in clipboard */	138	/* TODO jpound - support non-text in clipboard */
130	attachPage.populateAttachment();	139	attachPage.populateAttachment();
Lines 159-177 Link Here
159	task.setSynchronizationState(RepositoryTaskSyncState.OUTGOING);	168	task.setSynchronizationState(RepositoryTaskSyncState.OUTGOING);
160		169
161	if (screenshotMode \|\| InputAttachmentSourcePage.SCREENSHOT_LABEL.equals(path)) {	170	if (screenshotMode \|\| InputAttachmentSourcePage.SCREENSHOT_LABEL.equals(path)) {
162	Image image = shotPage.getScreenshotImage();	171	((ImageAttachment) attachment).ensureImageFileWasCreated();
163	if (image == null) {
164	throw new InvocationTargetException(new CoreException(new RepositoryStatus(IStatus.ERROR,
165	TasksUiPlugin.ID_PLUGIN, RepositoryStatus.ERROR_INTERNAL, "Screenshot is empty",
166	null)));
167	}
168	String path = TasksUiPlugin.getDefault().getDefaultDataDirectory();
169	ImageLoader loader = new ImageLoader();
170	loader.data = new ImageData[] { image.getImageData() };
171	String fileName = path + "/" + SCREENSHOT_FILENAME;
172	loader.save(fileName, SWT.IMAGE_JPEG);
173	attachment.setFile(new File(fileName));
174	attachment.setFilename(SCREENSHOT_FILENAME);
175	} else if (InputAttachmentSourcePage.CLIPBOARD_LABEL.equals(path)) {	172	} else if (InputAttachmentSourcePage.CLIPBOARD_LABEL.equals(path)) {
176	String contents = inputPage.getClipboardContents();	173	String contents = inputPage.getClipboardContents();
177	if (contents == null) {	174	if (contents == null) {
Lines 293-299 Link Here
293	@Override	290	@Override
294	public boolean canFinish() {	291	public boolean canFinish() {
295	if (screenshotMode) {	292	if (screenshotMode) {
296	return shotPage.isPageComplete();	293	return shotPage.isPageComplete() && attachPage.isPageComplete();
297	} else {	294	} else {
298	return attachPage.isPageComplete();	295	return attachPage.isPageComplete();
299	}	296	}
Lines 303-309 Link Here
303	public void addPages() {	300	public void addPages() {
304	super.addPages();	301	super.addPages();
305	if (screenshotMode) {	302	if (screenshotMode) {
306	addPage((shotPage = new ScreenshotAttachmentPage(attachment)));	303	addPage(shotPage);
307	addPage((attachPage = new NewAttachmentPage(attachment)));	304	addPage((attachPage = new NewAttachmentPage(attachment)));
308	} else {	305	} else {
309	if ("".equals(attachment.getFilePath())) {	306	if ("".equals(attachment.getFilePath())) {

Lines 13-22 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/wizards/PreviewAttachmentPage.java (-1 / +23 lines)
13	import java.io.FileNotFoundException;	13	import java.io.FileNotFoundException;
14	import java.io.FileReader;	14	import java.io.FileReader;
15	import java.io.IOException;	15	import java.io.IOException;
		16	import java.lang.reflect.InvocationTargetException;
16	import java.util.HashMap;	17	import java.util.HashMap;
17		18
		19	import org.eclipse.core.runtime.IProgressMonitor;
18	import org.eclipse.jface.layout.GridDataFactory;	20	import org.eclipse.jface.layout.GridDataFactory;
19	import org.eclipse.jface.layout.GridLayoutFactory;	21	import org.eclipse.jface.layout.GridLayoutFactory;
		22	import org.eclipse.jface.operation.IRunnableWithProgress;
20	import org.eclipse.jface.wizard.WizardPage;	23	import org.eclipse.jface.wizard.WizardPage;
21	import org.eclipse.mylyn.internal.tasks.core.LocalAttachment;	24	import org.eclipse.mylyn.internal.tasks.core.LocalAttachment;
22	import org.eclipse.swt.SWT;	25	import org.eclipse.swt.SWT;
Lines 50-56 Link Here
50	private static final String TITLE = "Attachment Preview";	53	private static final String TITLE = "Attachment Preview";
51		54
52	private static final String DESCRIPTION = "Review the attachment before submitting";	55	private static final String DESCRIPTION = "Review the attachment before submitting";
53		56
54	private LocalAttachment attachment;	57	private LocalAttachment attachment;
55		58
56	private static HashMap<String, String> textTypes;	59	private static HashMap<String, String> textTypes;
Lines 93-98 Link Here
93	composite.setLayout(new GridLayout());	96	composite.setLayout(new GridLayout());
94	setControl(composite);	97	setControl(composite);
95		98
		99	if (attachment instanceof ImageAttachment) {
		100	try {
		101	getContainer().run(true, false, new IRunnableWithProgress() {
		102	public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
		103	monitor.beginTask("Preparing image for preview...", 1);
		104	((ImageAttachment) attachment).ensureImageFileWasCreated();
		105	monitor.worked(1);
		106	monitor.done();
		107	}
		108	});
		109	} catch (InvocationTargetException e) {
		110	createErrorPreview(composite, "Could not create image for preview");
		111	return;
		112	} catch (InterruptedException e) {
		113	createErrorPreview(composite, "Could not create image for preview");
		114	return;
		115	}
		116	}
		117
96	if (InputAttachmentSourcePage.CLIPBOARD_LABEL.equals(attachment.getFilePath())) {	118	if (InputAttachmentSourcePage.CLIPBOARD_LABEL.equals(attachment.getFilePath())) {
97	createTextPreview(composite, ((NewAttachmentWizard) getWizard()).getClipboardContents());	119	createTextPreview(composite, ((NewAttachmentWizard) getWizard()).getClipboardContents());
98	} else if (PreviewAttachmentPage.isTextAttachment(attachment.getContentType())) {	120	} else if (PreviewAttachmentPage.isTextAttachment(attachment.getContentType())) {

Added Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/wizards/ColorSelectionWindow.java (+116 lines)
1	/*******************************************************************************
2	* Copyright (c) 2004, 2007 Mylyn project committers and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*******************************************************************************/
8
9	package org.eclipse.mylyn.internal.tasks.ui.wizards;
10
11	import org.eclipse.jface.layout.GridDataFactory;
12	import org.eclipse.jface.layout.GridLayoutFactory;
13	import org.eclipse.jface.window.Window;
14	import org.eclipse.swt.SWT;
15	import org.eclipse.swt.events.MouseAdapter;
16	import org.eclipse.swt.events.MouseEvent;
17	import org.eclipse.swt.events.SelectionAdapter;
18	import org.eclipse.swt.events.SelectionEvent;
19	import org.eclipse.swt.events.ShellAdapter;
20	import org.eclipse.swt.events.ShellEvent;
21	import org.eclipse.swt.graphics.RGB;
22	import org.eclipse.swt.widgets.Button;
23	import org.eclipse.swt.widgets.Composite;
24	import org.eclipse.swt.widgets.Control;
25	import org.eclipse.swt.widgets.Shell;
26
27	/**
28	* Popup window for color selection
29	*
30	* @author Willian Mitsuda
31	*/
32	public class ColorSelectionWindow extends Window {
33
34	private ColorCanvas[] colors;
35
36	public ColorSelectionWindow(Shell shell) {
37	super(shell);
38	setShellStyle(SWT.BORDER);
39	}
40
41	@Override
42	protected void configureShell(Shell newShell) {
43	super.configureShell(newShell);
44	newShell.addShellListener(new ShellAdapter() {
45
46	@Override
47	public void shellDeactivated(ShellEvent e) {
48	close();
49	}
50
51	});
52	}
53
54	@Override
55	protected Control createContents(Composite parent) {
56	Composite colorComposite = new Composite(parent, SWT.NONE);
57	colorComposite.setBackground(getShell().getDisplay().getSystemColor(SWT.COLOR_BLACK));
58	colorComposite.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).create());
59	colorComposite.setLayout(GridLayoutFactory.fillDefaults().numColumns(8).spacing(1, 1).margins(1, 1).equalWidth(
60	true).create());
61
62	// EGA classic palette
63	colors = new ColorCanvas[16];
64	colors[0] = createColorCanvas(colorComposite, new RGB(0, 0, 0));
65	colors[1] = createColorCanvas(colorComposite, new RGB(0, 0, 170));
66	colors[2] = createColorCanvas(colorComposite, new RGB(0, 170, 0));
67	colors[3] = createColorCanvas(colorComposite, new RGB(0, 170, 170));
68	colors[4] = createColorCanvas(colorComposite, new RGB(170, 0, 0));
69	colors[5] = createColorCanvas(colorComposite, new RGB(170, 0, 170));
70	colors[6] = createColorCanvas(colorComposite, new RGB(170, 85, 0));
71	colors[7] = createColorCanvas(colorComposite, new RGB(170, 170, 170));
72	colors[8] = createColorCanvas(colorComposite, new RGB(85, 85, 85));
73	colors[9] = createColorCanvas(colorComposite, new RGB(85, 85, 255));
74	colors[10] = createColorCanvas(colorComposite, new RGB(85, 255, 85));
75	colors[11] = createColorCanvas(colorComposite, new RGB(85, 255, 255));
76	colors[12] = createColorCanvas(colorComposite, new RGB(255, 85, 85));
77	colors[13] = createColorCanvas(colorComposite, new RGB(255, 85, 255));
78	colors[14] = createColorCanvas(colorComposite, new RGB(255, 255, 85));
79	colors[15] = createColorCanvas(colorComposite, new RGB(255, 255, 255));
80
81	Button closeButton = new Button(parent, SWT.PUSH);
82	closeButton.setText("&Close");
83	closeButton.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).create());
84	closeButton.addSelectionListener(new SelectionAdapter() {
85
86	@Override
87	public void widgetSelected(SelectionEvent e) {
88	close();
89	}
90
91	});
92	return parent;
93	}
94
95	private ColorCanvas createColorCanvas(Composite parent, RGB rgb) {
96	final ColorCanvas canvas = new ColorCanvas(parent, SWT.NONE, rgb);
97	canvas.setLayoutData(GridDataFactory.fillDefaults().hint(16, 16).create());
98	canvas.addMouseListener(new MouseAdapter() {
99
100	@Override
101	public void mouseDown(MouseEvent e) {
102	selectedRGB = canvas.getRGB();
103	close();
104	}
105
106	});
107	return canvas;
108	}
109
110	private RGB selectedRGB;
111
112	public RGB getSelectedRGB() {
113	return selectedRGB;
114	}
115
116	}