Attachment #127915 for bug #266123

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
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.dialogs.Dialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.mylyn.internal.commons.ui.ColorSelectionWindow;
import org.eclipse.mylyn.internal.commons.ui.Messages;
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.PaintListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
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.GridData;
import org.eclipse.swt.layout.GridLayout;
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.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.progress.UIJob;

/**

 */
public class ScreenshotCreationPage extends WizardPage implements IImageCreator {

	private ScreenshotToolbar toolbar;

	private Font markFont;

	private Color markFontColor;

	private IAction markAction;

	private IAction colorAction;

	private Image colorIcon;

	private Color markColor;

	private IAction clearAction;

	private boolean imageDirty;

	/**

	 */
	private Image workImage;

	private Image previousImage;

	/**
	 * Used to draw into {@link #workImage}
	 */

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

		CROPPING, SELECTING, RESIZING_SELECTION, MOVING_SELECTION, MARKING;

	};

	/**

	 */
	private EditorAction currentAction = EditorAction.CROPPING;

	private boolean isFirstCapture = true;

	/**
	 * Mouse event history.
	 * 
	 * [0] MouseDown/MouseMove/MouseUp, [1] x, [2] y
	 */
	private List<int[]> historyMouseEvent = new ArrayList<int[]>();

	/**
	 * Draw tool history.
	 * 
	 * [0] drawHistory index, [1] TEXT/FREE/LINE/..., [2] Line type, [3] Bold, [4] R/G/B
	 */
	private List<int[]> historyDrawTool = new ArrayList<int[]>();

	private List<String> historyDrawFont = new ArrayList<String>();

	private int historyCheckpoint = 0;

	private Text textArea;

	private List<StringBuffer> historyDrawText = new ArrayList<StringBuffer>();

	public ScreenshotCreationPage() {
		super("ScreenShotAttachment"); //$NON-NLS-1$
		setTitle(Messages.ScreenshotCreationPage_CAPTURE_SCRRENSHOT);

	}

	public void createControl(Composite parent) {
		Composite vf = new Composite(parent, SWT.NONE);
		vf.horizontalSpacing = 0;
		vf.verticalSpacing = 0;
		setControl(vf);
		vf.setLayoutData(GridDataFactory.fillDefaults().create());
		GridLayout layout = new GridLayout(2, false);
		layout.marginWidth = 0;
		layout.marginHeight = 0;
		layout.verticalSpacing = 0;
		layout.horizontalSpacing = 2;
		vf.setLayout(layout);

		toolbar = new ScreenshotToolbar(vf, SWT.BORDER) {

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

			private boolean isFirstCapture = true;

			@Override
			public void run(ScreenshotToolbar.Capture action) {
				if (action == ScreenshotToolbar.Capture.CLIPBOARD) {
					Image newimage = toolbar.getClipboardImage();
					if (newimage == null) {
						// TODO show messagebox
						return;
					}
					captureScreenshotContent(newimage);
				} else if (action == ScreenshotToolbar.Capture.FILE) {
					Image newimage = toolbar.getFileImage();
					if (newimage == null) {
						// TODO show messagebox
						return;
					}
					captureScreenshotContent(newimage);
				} else if (action == ScreenshotToolbar.Capture.CUT) {
					captureScreenshotContentFromSelection();
				} else {
					captureScreenshotContent();
				}
				setErrorMessage(null);
				if (isFirstCapture) {
					isFirstCapture = false;
					toolbar.setEnabled((ScreenshotToolbar.Tool) null, true);
					cropAction.setEnabled(true);
					cropAction.setChecked(true);
					markAction.setEnabled(true);
					clearAction.setEnabled(false);
				}

				historyMouseEvent = new ArrayList<int[]>();
				historyDrawTool = new ArrayList<int[]>();
				historyDrawText = new ArrayList<StringBuffer>();
				historyDrawFont = new ArrayList<String>();
				historyCheckpoint = 0;
				toolbar.setEnabled(ScreenshotToolbar.Clear.CLEAR, false);
				toolbar.setEnabled(ScreenshotToolbar.Clear.UNDO, false);
				toolbar.setEnabled(ScreenshotToolbar.Clear.REDO, false);
			}

			@Override
			public void run(ScreenshotToolbar.Clear action) {
				if (action == ScreenshotToolbar.Clear.CLEAR) {
					toolbar.setEnabled(ScreenshotToolbar.Clear.CLEAR, false);

					workImageGC.drawImage(originalImage, 0, 0);
					canvas.redraw();
					setImageDirty(true);
//		captureDelayedButton.setText(captureIn + secondsDelay +" seconds");
//		captureDelayedButton.setImage(TasksUiImages.getImage(TasksUiImages.IMAGE_CAPTURE));
//		captureDelayedButton.addSelectionListener(new SelectionListener() {
//
//			public void widgetSelected(SelectionEvent e) {
//				PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
//					public void run() {
//						getShell().setVisible(false);
//						for (int i = 1; i <= secondsDelay; i++) {
//							try {
//								Thread.sleep(1000);
////								captureDelayedButton.setText("Capture in " + (secondsDelay-i) + " seconds");
//							} catch (InterruptedException e1) {
//								// ignore
//							}	
//						}
//						captureScreenshotContent();
//						page.setErrorMessage(null);
//						fitButton.setEnabled(true);
//						captureDelayedButton.setText(captureIn + secondsDelay +" seconds");			
//						getShell().setVisible(true);
//					}
//				});
//			}
//
//			public void widgetDefaultSelected(SelectionEvent e) {
//				//ignore
//			}
//		});

					historyMouseEvent = new ArrayList<int[]>();
					historyDrawTool = new ArrayList<int[]>();
					historyDrawText = new ArrayList<StringBuffer>();
					historyDrawFont = new ArrayList<String>();
					historyCheckpoint = 0;
					toolbar.setEnabled(ScreenshotToolbar.Clear.UNDO, false);
					toolbar.setEnabled(ScreenshotToolbar.Clear.REDO, false);
				} else if (action == ScreenshotToolbar.Clear.UNDO) {
					if (historyCheckpoint > 0) {
						historyCheckpoint--;
						drawAnnotationHistory();
					}
					if (historyCheckpoint == 0) {
						toolbar.setEnabled(ScreenshotToolbar.Clear.UNDO, false);
					}
					if (historyCheckpoint < historyDrawTool.size()) {
						toolbar.setEnabled(ScreenshotToolbar.Clear.REDO, true);
					}
				} else if (action == ScreenshotToolbar.Clear.REDO) {
					if (historyCheckpoint < historyDrawTool.size()) {
						historyCheckpoint++;
						drawAnnotationHistory();
					}
					if (historyCheckpoint > 0) {
						toolbar.setEnabled(ScreenshotToolbar.Clear.UNDO, true);
					}
					if (historyCheckpoint >= historyDrawTool.size()) {
						toolbar.setEnabled(ScreenshotToolbar.Clear.REDO, false);
					}
				}
			}
		};
		fitAction.setToolTipText(Messages.ScreenshotCreationPage_Fit_Image);
		fitAction.setText(Messages.ScreenshotCreationPage_Fit_Image_F);
		fitAction.setImageDescriptor(ImageDescriptor.createFromImage(CommonImages.getImage(CommonImages.IMAGE_FIT)));
		fitAction.setChecked(true);
		fitAction.setEnabled(false);

		cropAction = new Action(Messages.ScreenshotCreationPage_Crop_R, IAction.AS_RADIO_BUTTON) {
			@Override
			public void selectedTool(ScreenshotToolbar.Tool tool) {
				if (tool == ScreenshotToolbar.Tool.RECT) {
					currentAction = EditorAction.CROPPING;
					toolbar.setEnabled(ScreenshotToolbar.Clear.UNDO, false);
					toolbar.setEnabled(ScreenshotToolbar.Clear.REDO, false);
					canvas.redraw();
				} else if (tool == ScreenshotToolbar.Tool.DRAW) {
					currentAction = EditorAction.MARKING;
					toolbar.setEnabled(ScreenshotToolbar.Clear.UNDO, false);
					toolbar.setEnabled(ScreenshotToolbar.Clear.REDO, false);
					canvas.redraw();
				} else if (tool == ScreenshotToolbar.Tool.TEXT) {
					currentAction = EditorAction.MARKING;
					toolbar.setEnabled(ScreenshotToolbar.Clear.UNDO, false);
					toolbar.setEnabled(ScreenshotToolbar.Clear.REDO, false);
					canvas.redraw();
				}
			}
		};
		cropAction.setToolTipText(Messages.ScreenshotCreationPage_Crop);
		cropAction.setImageDescriptor(CommonImages.CUT);
		cropAction.setEnabled(false);

		markAction = new Action(Messages.ScreenshotCreationPage_Annotate, IAction.AS_RADIO_BUTTON) {
			@Override
			public void selectedZoom(Zoom zoom) {
				refreshCanvasSize();
				cropAction.setChecked(false);
				markAction.setChecked(true);
				colorAction.setEnabled(true);
				canvas.redraw();
			}
		};
		markAction.setToolTipText(Messages.ScreenshotCreationPage_DRAW_ANNOTATION_ON_SCREENSHOT_IMAGE);
		markAction.setImageDescriptor(CommonImages.EDIT);
//		markAction.setDisabledImageDescriptor(ImageDescriptor.createFromFile(getClass(), "mark_disabled.gif"));
		markAction.setEnabled(false);

		colorAction = new Action("", IAction.AS_DROP_DOWN_MENU) { //$NON-NLS-1$
			@Override
			public void selectedColor(RGB rgb) {
				setMarkColor(rgb);

					@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(Messages.ScreenshotCreationPage_Change_pen_color);
		colorIcon = new Image(getShell().getDisplay(), 16, 16);
		setMarkColor(new RGB(255, 85, 85));
		colorAction.setEnabled(false);

		clearAction = new Action(Messages.ScreenshotCreationPage_Clear_Annotations, IAction.AS_PUSH_BUTTON) {
			@Override
			public void selectedFont(Font font, RGB rgb) {
				setMarkFont(toolbar.getTextFont().getFontData(), toolbar.getTextColor());
				workImageGC.drawImage(originalImage, 0, 0);
				canvas.redraw();
				setImageDirty(true);
			}
		};
		clearAction.setToolTipText(Messages.ScreenshotCreationPage_Clear_all_annotations_made_on_screenshot_image);
		clearAction.setImageDescriptor(CommonImages.CLEAR);
		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));

		GridData gd = new GridData(GridData.HORIZONTAL_ALIGN_BEGINNING | GridData.FILL_VERTICAL);
		toolbar.setLayoutData(gd);
		toolbar.setEnabled((ScreenshotToolbar.Tool) null, false);
		toolbar.setEnabled(ScreenshotToolbar.Capture.CUT, false);
		toolbar.setEnabled(ScreenshotToolbar.Clear.CLEAR, false);
		toolbar.setEnabled(ScreenshotToolbar.Clear.UNDO, false);
		toolbar.setEnabled(ScreenshotToolbar.Clear.REDO, false);

		allocateCursors();

		ScreenshotToolbar.Tool tool = toolbar.getTool();
		if (tool == ScreenshotToolbar.Tool.RECT) {
			currentAction = EditorAction.CROPPING;
		} else if (tool == ScreenshotToolbar.Tool.DRAW) {
			currentAction = EditorAction.MARKING;
		} else if (tool == ScreenshotToolbar.Tool.TEXT) {
			currentAction = EditorAction.MARKING;
		}
		setMarkColor(toolbar.getDrawColor());
		setMarkFont(toolbar.getTextFont().getFontData(), toolbar.getTextColor());

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

					Rectangle imageBounds = workImage.getBounds();
					Rectangle canvasBounds = canvas.getClientArea();

					ScreenshotToolbar.Zoom zoom = toolbar.getZoom();
					if (zoom == ScreenshotToolbar.Zoom.FIT) {
						e.gc.drawImage(workImage, 0, 0, imageBounds.width, imageBounds.height, //
								0, 0, canvasBounds.width, canvasBounds.height);
					} else if (zoom == ScreenshotToolbar.Zoom.ZOOM8X) {
						e.gc.drawImage(workImage, 0, 0, imageBounds.width, imageBounds.height, //
								0, 0, imageBounds.width * 8, imageBounds.height * 8);
					} else if (zoom == ScreenshotToolbar.Zoom.ZOOM4X) {
						e.gc.drawImage(workImage, 0, 0, imageBounds.width, imageBounds.height, //
								0, 0, imageBounds.width * 4, imageBounds.height * 4);
					} else if (zoom == ScreenshotToolbar.Zoom.ZOOM2X) {
						e.gc.drawImage(workImage, 0, 0, imageBounds.width, imageBounds.height, //
								0, 0, imageBounds.width * 2, imageBounds.height * 2);
					} else if (zoom == ScreenshotToolbar.Zoom.ZOOMHALF) {
						e.gc.drawImage(workImage, 0, 0, imageBounds.width, imageBounds.height, //
								0, 0, imageBounds.width / 2, imageBounds.height / 2);
					} else {
						e.gc.drawImage(workImage, 0, 0);
					}
					drawSelection(e.gc);
				} else {
//					page.setErrorMessage("Screenshot required");
					toolbar.setEnabled(ScreenshotToolbar.Tool.ZOOM, false);
				}
			}
		});

		scrolledComposite.addControlListener(new ControlAdapter() {
			@Override
			public void controlResized(ControlEvent e) {
				if (toolbar.getZoom() == ScreenshotToolbar.Zoom.FIT) {
					refreshCanvasSize();
				}
			}
		});
		scrolledComposite.setEnabled(false);

		scrolledComposite.setLayoutData(new GridData(GridData.FILL_BOTH));

		registerMouseListeners();

		Dialog.applyDialogFont(vf);
	}

	private void setMarkFont(FontData[] fontData, RGB fontColor) {
		if (markFont != null) {
			markFont.dispose();
		}
		markFont = new Font(getShell().getDisplay(), fontData[0]);
		markFontColor = new Color(getShell().getDisplay(), fontColor);
	}

	private void setMarkColor(RGB 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

		if (markColor != null) {
			markColor.dispose();
		}
		if (colorIcon != null) {
			colorIcon.dispose();
		}

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

		return isPageComplete();
	}

	private void captureScreenshotContent(Image image) {
		Display display = getShell().getDisplay();
		disposeImageResources();
		originalImage = image;
		Rectangle displayBounds = originalImage.getBounds();
		workImage = new Image(display, displayBounds.width, displayBounds.height);
		GC gc = new GC(workImage);
		gc.drawImage(originalImage, 0, 0);
		gc.dispose();

		workImageGC = new GC(workImage);
		workImageGC.setBackground(new Color(getShell().getDisplay(), 255, 255, 255));
		workImageGC.setForeground(markColor);
		workImageGC.setLineWidth(4);
		workImageGC.setLineCap(SWT.CAP_ROUND);

		scrolledComposite.setEnabled(true);
		clearSelection();
		refreshCanvasSize();

		setPageComplete(true);
	}

	private void captureScreenshotContentFromSelection() {
		Display display = getShell().getDisplay();

		Image image = new Image(display, currentSelection);
		GC gc = new GC(image);
		gc.drawImage(workImage, currentSelection.x, currentSelection.y, currentSelection.width,
				currentSelection.height, 0, 0, currentSelection.width, currentSelection.height);
		gc.dispose();
		disposeImageResources();

		originalImage = image;
		Rectangle displayBounds = originalImage.getBounds();
		workImage = new Image(display, displayBounds.width, displayBounds.height);
		gc = new GC(workImage);
		gc.drawImage(originalImage, 0, 0);
		gc.dispose();

		workImageGC = new GC(workImage);
		workImageGC.setBackground(new Color(getShell().getDisplay(), 255, 255, 255));
		workImageGC.setForeground(markColor);
		workImageGC.setLineWidth(4);
		workImageGC.setLineCap(SWT.CAP_ROUND);

		scrolledComposite.setEnabled(true);
		clearSelection();
		refreshCanvasSize();

		setPageComplete(true);
	}

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

		int height = Math.abs(startPoint.y - y);
		currentSelection = new Rectangle(startX, startY, width, height);

		toolbar.setEnabled(ScreenshotToolbar.Capture.CUT, true);

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

	private void refreshSelectionResize(int x, int y) {
		currentSelection = new Rectangle(originalSelection.x, originalSelection.y, originalSelection.width,
				originalSelection.height);

		toolbar.setEnabled(ScreenshotToolbar.Capture.CUT, true);

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

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

		toolbar.setEnabled(ScreenshotToolbar.Capture.CUT, true);

		setUpGrabPoints();
	}


						canvas.setCursor(crossCursor);
					}
				} else if (currentAction == EditorAction.MARKING) {
					if (startPoint != null) {
						if (toolbar.getDrawTool() == ScreenshotToolbar.Draw.FREE) {
							int[] history = new int[3];
							history[0] = SWT.MouseMove;
							history[1] = scaledX;
							history[2] = scaledY;
							historyMouseEvent.add(history);
						} else {
							int[] history = historyMouseEvent.get(historyMouseEvent.size() - 1);
							if (history[0] == SWT.MouseMove) {
								history[1] = scaledX;
								history[2] = scaledY;
							} else {
								history = new int[3];
								history[0] = SWT.MouseMove;
								history[1] = scaledX;
								history[2] = scaledY;
								historyMouseEvent.add(history);
							}
						}
					}

					drawMarkLine(scaledX, scaledY);

					Cursor markCursor = cursors.get(CURSOR_MARK_TOOL);

					}
					if (currentSelection.width == 0 && currentSelection.height == 0) {
						currentSelection = null;

						toolbar.setEnabled(ScreenshotToolbar.Capture.CUT, false);
					}
					setUpGrabPoints();
					startPoint = null;

					canvas.redraw();
					setImageDirty(true);
				} else if (currentAction == EditorAction.MARKING) {
					if (startPoint != null) {
						if (toolbar.getTool() == ScreenshotToolbar.Tool.DRAW) {
							if (toolbar.getDrawTool() != ScreenshotToolbar.Draw.FREE) {
								previousImage.dispose();
								previousImage = null;
							}

							int[] history = new int[3];
							history[0] = SWT.MouseUp;
							history[1] = 0;
							history[2] = 0;
							historyMouseEvent.add(history);
						} else if (toolbar.getTool() == ScreenshotToolbar.Tool.TEXT) {
							drawAnnotationText();

							int[] history = new int[3];
							history[0] = SWT.MouseUp;
							history[1] = 0;
							history[2] = 0;
							historyMouseEvent.add(history);
						}
					}

					startPoint = null;
					setImageDirty(true);

				}
			}

			/**
			 * Input annotation text and draw text
			 */
			private void drawAnnotationText() {
				workImageGC.drawImage(previousImage, 0, 0);

				int[] history = historyMouseEvent.get(historyMouseEvent.size() - 1);
				if (history[0] != SWT.MouseMove) {
					historyCheckpoint--;
					updateAnnotationHistory();
					return;
				}

				final Rectangle bounds = new Rectangle(startPoint.x, startPoint.y, history[1] - startPoint.x,
						history[2] - startPoint.y);

				textArea = new Text(canvas, SWT.MULTI | SWT.WRAP);
				textArea.addListener(SWT.Deactivate, new Listener() {

					public void handleEvent(Event event) {
						String text = textArea.getText();
						{
							String newtext = ""; //$NON-NLS-1$
							int currpos = 0;
							int charpos = currpos;
							textArea.setTopIndex(0);
							textArea.setSelection(currpos);
							int linepos = textArea.getCaretLineNumber();
							boolean remove1st = false;
							String line;
							while (currpos < text.length()) {
								int y = textArea.getCaretLineNumber();
								if (linepos != y) {
									line = text.substring(charpos, currpos);
									if (line.endsWith("\n")) { //$NON-NLS-1$
										line = line.substring(0, line.length() - 1);
									}
									newtext = newtext + "\n" + line; //$NON-NLS-1$
									remove1st = true;
									charpos = currpos;
									linepos = y;
								}
								currpos++;
								textArea.setSelection(currpos);
							}
							line = text.substring(charpos, currpos);
							if (line.endsWith("\n")) { //$NON-NLS-1$
								line = line.substring(0, line.length() - 1);
							}
							if (line.length() > 0) {
								newtext = newtext + "\n" + text.substring(charpos, currpos); //$NON-NLS-1$
								remove1st = true;
							}
							currpos = newtext.indexOf("\r"); //$NON-NLS-1$
							while (currpos > 0) {
								newtext = newtext.substring(0, currpos) + newtext.substring(currpos + 1);
								currpos = newtext.indexOf("\r"); //$NON-NLS-1$
							}
							newtext = newtext.replace("\t", " "); //$NON-NLS-1$ //$NON-NLS-2$
							if (remove1st) {
								newtext = newtext.substring(1);
							}
							text = newtext;
						}

						textArea.dispose();
						textArea = null;

						if (text.length() > 0) {
							historyDrawText.get(historyCheckpoint - 1).append(text);
							workImageGC.setFont(markFont);
							workImageGC.setForeground(markFontColor);
							workImageGC.setClipping(bounds);
							workImageGC.drawText(text, bounds.x, bounds.y, true);
							workImageGC.setClipping((Rectangle) null);
							workImageGC.setForeground(markColor);
						} else {
							historyCheckpoint--;
							updateAnnotationHistory();
						}
						canvas.redraw();
					}
				});

				textArea.setFocus();
				int xs = (int) Math.round(startPoint.x * scaleFactor);
				int ys = (int) Math.round(startPoint.y * scaleFactor);
				int xe = (int) Math.round(history[1] * scaleFactor);
				int ye = (int) Math.round(history[2] * scaleFactor);
				textArea.setBounds(new Rectangle(xs, ys, xe - xs, ye - ys));
				if (scaleFactor != 1.0) {
					FontData[] fd = markFont.getFontData();
					fd[0].setHeight((int) Math.round(fd[0].getHeight() * scaleFactor));
					textArea.setFont(new Font(getShell().getDisplay(), fd[0]));
				} else {
					textArea.setFont(markFont);
				}
				textArea.setForeground(markFontColor);
				textArea.setTabs(1);
				Point point = textArea.getCaretLocation();
				textArea.setBounds(new Rectangle(xs - point.x, ys, xe - xs + point.x + point.x, ye - ys));
			}

			/**

				int scaledY = (int) (e.y / scaleFactor);

				if (currentAction == EditorAction.MARKING) {
					updateAnnotationHistory();

					ScreenshotToolbar.Tool toolKind = toolbar.getTool();
					int[] history = new int[5];
					history[0] = historyMouseEvent.size();
					history[1] = toolbar.getDrawTool().hashCode();
					history[2] = toolbar.getLineStyle();
					history[3] = toolbar.getLineBold();
					if (toolKind == ScreenshotToolbar.Tool.TEXT) {
						history[1] = toolKind.hashCode();
						history[4] = (markFontColor.getRed() << 16) //
								+ (markFontColor.getGreen() << 8) //
								+ markFontColor.getBlue();
					} else {
						history[4] = (markColor.getRed() << 16) //
								+ (markColor.getGreen() << 8) //
								+ markColor.getBlue();
					}
					historyDrawTool.add(history);
					historyDrawText.add(new StringBuffer());
					if (toolKind == ScreenshotToolbar.Tool.TEXT) {
						FontData[] fd = markFont.getFontData();
						historyDrawFont.add(fd[0].toString());
					} else {
						historyDrawFont.add(""); //$NON-NLS-1$
					}
					historyCheckpoint = historyDrawTool.size();

					history = new int[3];
					history[0] = SWT.MouseDown;
					history[1] = scaledX;
					history[2] = scaledY;
					historyMouseEvent.add(history);
					toolbar.setEnabled(ScreenshotToolbar.Clear.UNDO, true);

					if (toolKind != ScreenshotToolbar.Tool.TEXT) {
						if (toolbar.getDrawTool() != ScreenshotToolbar.Draw.FREE) {
							Display display = getShell().getDisplay();
							previousImage = new Image(display, workImage.getBounds());
							GC gc = new GC(previousImage);
							gc.drawImage(workImage, 0, 0);
							gc.dispose();
						}

						workImageGC.setLineStyle(toolbar.getLineStyle());
						workImageGC.setLineWidth(toolbar.getLineBold());
						workImageGC.setForeground(markColor);
					} else {
						Display display = getShell().getDisplay();
						previousImage = new Image(display, workImage.getBounds());
						GC gc = new GC(previousImage);
						gc.drawImage(workImage, 0, 0);
						gc.dispose();

						workImageGC.setLineStyle(SWT.LINE_DOT);
						workImageGC.setLineWidth(1);
						workImageGC.setForeground(new Color(getShell().getDisplay(), 0, 0, 0));
					}

					startPoint = new Point(scaledX, scaledY);
					drawMarkLine(scaledX, scaledY);
					canvas.setCursor(cursors.get(CURSOR_MARK_TOOL));

				canvas.setCursor(cursors.get(SWT.CURSOR_CROSS));
				currentAction = EditorAction.SELECTING;
				currentSelection = null;

				toolbar.setEnabled(ScreenshotToolbar.Capture.CUT, false);

				startPoint = new Point(scaledX, scaledY);
				setUpGrabPoints();
				canvas.redraw();


	private void clearSelection() {
		currentSelection = null;

		toolbar.setEnabled(ScreenshotToolbar.Capture.CUT, false);

		startPoint = null;
		setImageDirty(true);
	}

	 * Calling this method under other circumstances may lead to strange behavior in the scrolled composite
	 */
	private void refreshCanvasSize() {
		ScreenshotToolbar.Zoom zoom = toolbar.getZoom();
		if (zoom == ScreenshotToolbar.Zoom.FIT) {
			// 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);

			}
			canvas.setBounds(bounds);
		} else {
			if (zoom == ScreenshotToolbar.Zoom.ZOOM8X) {
				scaleFactor = 8.0;
			} else if (zoom == ScreenshotToolbar.Zoom.ZOOM4X) {
				scaleFactor = 4.0;
			} else if (zoom == ScreenshotToolbar.Zoom.ZOOM2X) {
				scaleFactor = 2.0;
			} else if (zoom == ScreenshotToolbar.Zoom.ZOOMHALF) {
				scaleFactor = 0.5;
			} else {
				scaleFactor = 1.0;
			}
			Rectangle bounds = scrolledComposite.getClientArea();
			if (workImage != null) {
				Rectangle imageBounds = workImage.getBounds();
				bounds.width = (int) Math.round(imageBounds.width * scaleFactor);
				bounds.height = (int) Math.round(imageBounds.height * scaleFactor);
			}
			canvas.setBounds(bounds);
		}

		canvas.redraw();
	}

	private void updateAnnotationHistory() {
		int[] history;
		if (historyCheckpoint < historyDrawTool.size()) {
			history = historyDrawTool.get(historyCheckpoint);
			while (history[0] < historyMouseEvent.size()) {
				historyMouseEvent.remove(historyMouseEvent.size() - 1);
			}
			while (historyCheckpoint < historyDrawTool.size()) {
				historyDrawTool.remove(historyDrawTool.size() - 1);
			}
			while (historyCheckpoint < historyDrawText.size()) {
				historyDrawText.remove(historyDrawText.size() - 1);
			}
			while (historyCheckpoint < historyDrawFont.size()) {
				historyDrawFont.remove(historyDrawFont.size() - 1);
			}
			toolbar.setEnabled(ScreenshotToolbar.Clear.REDO, false);
		}

		toolbar.setEnabled(ScreenshotToolbar.Clear.UNDO, historyCheckpoint > 0);
	}

	/**
	 * Draw Annotation with history
	 */
	private void drawAnnotationHistory() {
		workImageGC.drawImage(originalImage, 0, 0);
		int[] history;
		for (int c = 0; c < historyCheckpoint; c++) {
			history = historyDrawTool.get(c);
			int toolKind = history[1];
			int boldlKind = history[3];
			workImageGC.setLineStyle(history[2]);
			workImageGC.setLineWidth(boldlKind);
			workImageGC.setForeground(new Color(getShell().getDisplay(), //
					history[4] >> 16, //
					(history[4] >> 8) & 0x00ff, //
					history[4] & 0x00ff));

			int h = history[0];
			history = historyMouseEvent.get(h);
			int start_x = history[1];
			int start_y = history[2];
			for (h++; h < historyMouseEvent.size(); h++) {
				history = historyMouseEvent.get(h);
				if (history[0] == SWT.MouseUp) {
					break;
				}
				int x = history[1];
				int y = history[2];
				if (toolKind == ScreenshotToolbar.Draw.FREE.hashCode()) {
					workImageGC.drawLine(start_x, start_y, x, y);
					start_x = x;
					start_y = y;
				} else {
					if (start_x == x && start_y == y) {
						workImageGC.drawLine(start_x, start_y, x, y);
					} else {
						Color backColor;
						int rounded;
						int width = x - start_x;
						int height = y - start_y;
						if (toolKind == ScreenshotToolbar.Draw.LINE.hashCode()) {
							workImageGC.drawLine(start_x, start_y, x, y);
						} else if (toolKind == ScreenshotToolbar.Draw.BOX.hashCode()) {
							workImageGC.drawRectangle(start_x, start_y, width, height);
						} else if (toolKind == ScreenshotToolbar.Draw.RBOX.hashCode()) {
							rounded = boldlKind * 8;
							workImageGC.drawRoundRectangle(start_x, start_y, width, height, rounded, rounded);
						} else if (toolKind == ScreenshotToolbar.Draw.OVAL.hashCode()) {
							workImageGC.drawOval(start_x, start_y, width, height);
						} else if (toolKind == ScreenshotToolbar.Draw.FILL_BOX.hashCode()) {
							backColor = workImageGC.getBackground();
							workImageGC.setBackground(workImageGC.getForeground());
							workImageGC.fillRectangle(start_x, start_y, width, height);
							workImageGC.setBackground(backColor);
						} else if (toolKind == ScreenshotToolbar.Draw.FILL_RBOX.hashCode()) {
							rounded = boldlKind * 8;
							backColor = workImageGC.getBackground();
							workImageGC.setBackground(workImageGC.getForeground());
							workImageGC.fillRoundRectangle(start_x, start_y, width, height, rounded, rounded);
							workImageGC.setBackground(backColor);
						} else if (toolKind == ScreenshotToolbar.Draw.FILL_OVAL.hashCode()) {
							backColor = workImageGC.getBackground();
							workImageGC.setBackground(workImageGC.getForeground());
							workImageGC.fillOval(start_x, start_y, width, height);
							workImageGC.setBackground(backColor);
						} else if (toolKind == ScreenshotToolbar.Tool.TEXT.hashCode()) {
							StringBuffer text = historyDrawText.get(c);
							FontData fontData = new FontData(historyDrawFont.get(c));
							workImageGC.setFont(new Font(getShell().getDisplay(), fontData));
							workImageGC.setClipping(start_x, start_y, width, height);
							workImageGC.drawText(text.toString(), start_x, start_y, true);
							workImageGC.setClipping((Rectangle) null);
						}
					}
				}
			}
		}

		workImageGC.setForeground(markColor);
		workImageGC.setLineStyle(toolbar.getLineStyle());
		workImageGC.setLineWidth(toolbar.getLineBold());
		workImageGC.setFont(markFont);
		canvas.redraw();
	}

	/**
	 * Decorates the screenshot canvas with the selection rectangle, resize grab points and other adornments
	 */

	}

	/**
	 * Connects the previous mark point to the new reference point, by drawing a new line, rectangle or oval
	 */
	private void drawMarkLine(int x, int y) {
		if (startPoint != null) {
			toolbar.setEnabled(ScreenshotToolbar.Clear.CLEAR, true);
			if (toolbar.getTool() == ScreenshotToolbar.Tool.TEXT) {
				workImageGC.drawImage(previousImage, 0, 0);
				if (startPoint.x == x && startPoint.y == y) {
					workImageGC.drawLine(startPoint.x, startPoint.y, x, y);
				} else {
					int width = x - startPoint.x;
					int height = y - startPoint.y;
					workImageGC.fillRectangle(startPoint.x, startPoint.y, width, height);
					workImageGC.drawRectangle(startPoint.x, startPoint.y, width, height);
				}
			} else {
				ScreenshotToolbar.Draw draw = toolbar.getDrawTool();
				if (draw == ScreenshotToolbar.Draw.FREE) {
					workImageGC.drawLine(startPoint.x, startPoint.y, x, y);
					startPoint.x = x;
					startPoint.y = y;
				} else {
					workImageGC.drawImage(previousImage, 0, 0);
					if (startPoint.x == x && startPoint.y == y) {
						workImageGC.drawLine(startPoint.x, startPoint.y, x, y);
					} else {
						int width = x - startPoint.x;
						int height = y - startPoint.y;
						if (draw == ScreenshotToolbar.Draw.LINE) {
							workImageGC.drawLine(startPoint.x, startPoint.y, x, y);
						} else if (draw == ScreenshotToolbar.Draw.BOX) {
							workImageGC.drawRectangle(startPoint.x, startPoint.y, width, height);
						} else if (draw == ScreenshotToolbar.Draw.RBOX) {
							int rounded = toolbar.getLineBold() * 8;
							workImageGC.drawRoundRectangle(startPoint.x, startPoint.y, width, height, rounded, rounded);
						} else if (draw == ScreenshotToolbar.Draw.OVAL) {
							workImageGC.drawOval(startPoint.x, startPoint.y, width, height);
						} else if (draw == ScreenshotToolbar.Draw.FILL_BOX) {
							Color backColor = workImageGC.getBackground();
							workImageGC.setBackground(markColor);
							workImageGC.fillRectangle(startPoint.x, startPoint.y, width, height);
							workImageGC.setBackground(backColor);
						} else if (draw == ScreenshotToolbar.Draw.FILL_RBOX) {
							int rounded = toolbar.getLineBold() * 8;
							Color backColor = workImageGC.getBackground();
							workImageGC.setBackground(markColor);
							workImageGC.fillRoundRectangle(startPoint.x, startPoint.y, width, height, rounded, rounded);
							workImageGC.setBackground(backColor);
						} else if (draw == ScreenshotToolbar.Draw.FILL_OVAL) {
							Color backColor = workImageGC.getBackground();
							workImageGC.setBackground(markColor);
							workImageGC.fillOval(startPoint.x, startPoint.y, width, height);
							workImageGC.setBackground(backColor);
						}
					}
				}
			}
			canvas.redraw();
		}
	}

Lines 45-50 Link Here

(-)src/org/eclipse/mylyn/internal/provisional/commons/ui/CommonImages.java (+62 lines)
45		45
46	private static final String T_OVR = "ovr16"; //$NON-NLS-1$	46	private static final String T_OVR = "ovr16"; //$NON-NLS-1$
47		47
		48	private static final String T_BAR = "toolbar"; //$NON-NLS-1$
		49
48	// Priorities	50	// Priorities
49		51
50	public static final ImageDescriptor PRIORITY_1 = create(T_OBJ, "priority-1.gif"); //$NON-NLS-1$	52	public static final ImageDescriptor PRIORITY_1 = create(T_OBJ, "priority-1.gif"); //$NON-NLS-1$
Lines 201-206 Link Here
201		203
202	public static final ImageDescriptor FIND = create(T_TOOL, "find.gif"); //$NON-NLS-1$	204	public static final ImageDescriptor FIND = create(T_TOOL, "find.gif"); //$NON-NLS-1$
203		205
		206	public static final ImageDescriptor FILE_OBJ = create(T_TOOL, "file_obj.gif"); //$NON-NLS-1$
		207
		208	public static final ImageDescriptor CLIPBOARD_OBJ = create(T_TOOL, "clipboard_obj.gif"); //$NON-NLS-1$
		209
		210	public static final ImageDescriptor EDIT_TEXT = create(T_TOOL, "font.gif"); //$NON-NLS-1$
		211
		212	public static final ImageDescriptor EDIT_UNDO = create(T_TOOL, "undo_edit.gif"); //$NON-NLS-1$
		213
		214	public static final ImageDescriptor EDIT_REDO = create(T_TOOL, "redo_edit.gif"); //$NON-NLS-1$
		215
		216	public static final ImageDescriptor SEL_RECT = create(T_TOOL, "select_rect.gif"); //$NON-NLS-1$
		217
		218	public static final ImageDescriptor ZOOM_FIT = create(T_BAR, "zoom_fit.gif"); //$NON-NLS-1$
		219
		220	public static final ImageDescriptor ZOOM_HALF = create(T_BAR, "zoom_half.gif"); //$NON-NLS-1$
		221
		222	public static final ImageDescriptor ZOOM_1X = create(T_BAR, "zoom_1x.gif"); //$NON-NLS-1$
		223
		224	public static final ImageDescriptor ZOOM_2X = create(T_BAR, "zoom_2x.gif"); //$NON-NLS-1$
		225
		226	public static final ImageDescriptor ZOOM_4X = create(T_BAR, "zoom_4x.gif"); //$NON-NLS-1$
		227
		228	public static final ImageDescriptor ZOOM_8X = create(T_BAR, "zoom_8x.gif"); //$NON-NLS-1$
		229
		230	public static final ImageDescriptor EDIT_FREE = create(T_BAR, "edit_free.gif"); //$NON-NLS-1$
		231
		232	public static final ImageDescriptor EDIT_LINE = create(T_BAR, "edit_line.gif"); //$NON-NLS-1$
		233
		234	public static final ImageDescriptor EDIT_BOX = create(T_BAR, "edit_box.gif"); //$NON-NLS-1$
		235
		236	public static final ImageDescriptor EDIT_RBOX = create(T_BAR, "edit_rbox.gif"); //$NON-NLS-1$
		237
		238	public static final ImageDescriptor EDIT_OVAL = create(T_BAR, "edit_oval.gif"); //$NON-NLS-1$
		239
		240	public static final ImageDescriptor EDIT_FILL_BOX = create(T_BAR, "edit_fill_box.gif"); //$NON-NLS-1$
		241
		242	public static final ImageDescriptor EDIT_FILL_RBOX = create(T_BAR, "edit_fill_rbox.gif"); //$NON-NLS-1$
		243
		244	public static final ImageDescriptor EDIT_FILL_OVAL = create(T_BAR, "edit_fill_oval.gif"); //$NON-NLS-1$
		245
		246	public static final ImageDescriptor LINE_SOLD = create(T_BAR, "line_sold.gif"); //$NON-NLS-1$
		247
		248	public static final ImageDescriptor LINE_DOT = create(T_BAR, "line_dot.gif"); //$NON-NLS-1$
		249
		250	public static final ImageDescriptor LINE_DASH = create(T_BAR, "line_dash.gif"); //$NON-NLS-1$
		251
		252	public static final ImageDescriptor LINE_DASH1D = create(T_BAR, "line_dash1d.gif"); //$NON-NLS-1$
		253
		254	public static final ImageDescriptor LINE_DASH2D = create(T_BAR, "line_dash2d.gif"); //$NON-NLS-1$
		255
		256	public static final ImageDescriptor LINE_BOLD1 = create(T_BAR, "line_bold1.gif"); //$NON-NLS-1$
		257
		258	public static final ImageDescriptor LINE_BOLD2 = create(T_BAR, "line_bold2.gif"); //$NON-NLS-1$
		259
		260	public static final ImageDescriptor LINE_BOLD4 = create(T_BAR, "line_bold4.gif"); //$NON-NLS-1$
		261
		262	public static final ImageDescriptor LINE_BOLD8 = create(T_BAR, "line_bold8.gif"); //$NON-NLS-1$
		263
		264	public static final ImageDescriptor SEL_COLOR = create(T_BAR, "select_color.gif"); //$NON-NLS-1$
		265
204	private static ImageDescriptor create(String prefix, String name) {	266	private static ImageDescriptor create(String prefix, String name) {
205	try {	267	try {
206	return ImageDescriptor.createFromURL(makeIconFileURL(prefix, name));	268	return ImageDescriptor.createFromURL(makeIconFileURL(prefix, name));

Lines 15-29 Link Here

(-)src/org/eclipse/mylyn/internal/commons/ui/messages.properties (-3 / +60 lines)
15		15
16	ScreenshotCreationPage_After_capturing=After capturing, you can crop the image and make drawings on it. This window will not be captured.	16	ScreenshotCreationPage_After_capturing=After capturing, you can crop the image and make drawings on it. This window will not be captured.
17	ScreenshotCreationPage_Annotate=&Annotate	17	ScreenshotCreationPage_Annotate=&Annotate
18	ScreenshotCreationPage_Capture_Desktop=Capture Desktop	18	ScreenshotCreationPage_Capture_Desktop=Capture Desktop, Clipboard or File
19	ScreenshotCreationPage_Capture_Desktop_C=&Capture Desktop	19	ScreenshotCreationPage_Capture_Desktop_C=&Capture
20	ScreenshotCreationPage_CAPTURE_SCRRENSHOT=Capture Screenshot	20	ScreenshotCreationPage_CAPTURE_SCRRENSHOT=Capture Screenshot
21	ScreenshotCreationPage_Change_pen_color=Change pen color	21	ScreenshotCreationPage_Change_pen_color=Change pen color
		22	ScreenshotCreationPage_Change_text_font=Change text font
22	ScreenshotCreationPage_Clear_all_annotations_made_on_screenshot_image=Clear all annotations made on screenshot image	23	ScreenshotCreationPage_Clear_all_annotations_made_on_screenshot_image=Clear all annotations made on screenshot image
23	ScreenshotCreationPage_Clear_Annotations=C&lear Annotations	24	ScreenshotCreationPage_Clear_Annotations=C&lear Annotations
		25	ScreenshotCreationPage_Clear=C&lear
		26	ScreenshotCreationPage_Undo=&Undo
		27	ScreenshotCreationPage_Undo_annotation=Undo annotation
		28	ScreenshotCreationPage_Redo=Re&do
		29	ScreenshotCreationPage_Redo_annotation=Redo annotation
24	ScreenshotCreationPage_Crop=Crop	30	ScreenshotCreationPage_Crop=Crop
25	ScreenshotCreationPage_Crop_R=C&rop	31	ScreenshotCreationPage_Crop_R=C&rop
26	ScreenshotCreationPage_DRAW_ANNOTATION_ON_SCREENSHOT_IMAGE=Draw annotations on screenshot image	32	ScreenshotCreationPage_DRAW_ANNOTATION_ON_SCREENSHOT_IMAGE=Draw annotations on screenshot image
27	ScreenshotCreationPage_Fit_Image=Fit Image	33	ScreenshotCreationPage_Fit_Image=Fit Image
28	ScreenshotCreationPage_Fit_Image_F=&Fit Image	34	#ScreenshotCreationPage_Fit_Image_F=&Fit Image
		35	ScreenshotCreationPage_Fit_Image_F=&Fit
		36	ScreenshotCreationPage_Font_Bold=, Bold
		37	ScreenshotCreationPage_Font_Italic=, Italic
		38	ScreenshotCreationPage_Font_Name_Size={0}, {1} pt
29	ScreenshotCreationPage_NOTE_THAT_YOU_CONTINUTE=Note that you can continue to interact with the workbench in order to set up the screenshot.	39	ScreenshotCreationPage_NOTE_THAT_YOU_CONTINUTE=Note that you can continue to interact with the workbench in order to set up the screenshot.
		40
		41	ScreenshotToolbar_1dot=1 dot
		42	ScreenshotToolbar_2dots=2 dots
		43	ScreenshotToolbar_4dots=4 dots
		44	ScreenshotToolbar_8dots=8 dots
		45	ScreenshotToolbar_Clipboard=Clipboard
		46	ScreenshotToolbar_Custom=Custom
		47	ScreenshotToolbar_Cyan=Cyan
		48	ScreenshotToolbar_Desktop=Desktop
		49	ScreenshotToolbar_File=File...
		50	ScreenshotToolbar_Black=Black
		51	ScreenshotToolbar_Blue=Blue
		52	ScreenshotToolbar_Box=Rectangle
		53	ScreenshotToolbar_RBox=Round Rectangle
		54	ScreenshotToolbar_Red=Red
		55	ScreenshotToolbar_Oval=Oval
		56	ScreenshotToolbar_FillBox=Fill Rectangle
		57	ScreenshotToolbar_FillRBox=Fill Round Rectangle
		58	ScreenshotToolbar_FillOval=Fill Oval
		59	ScreenshotToolbar_Free=Free
		60	ScreenshotToolbar_Line=Line
		61	ScreenshotToolbar_Text=Text
		62	ScreenshotToolbar_Dark_Blue=Dark Blue
		63	ScreenshotToolbar_Dark_Cyan=Dark Cyan
		64	ScreenshotToolbar_Dark_Gray=Dark Gray
		65	ScreenshotToolbar_Dark_Green=Dark Green
		66	ScreenshotToolbar_Dark_Magenta=Dark Magenta
		67	ScreenshotToolbar_Dark_Red=Dark Red
		68	ScreenshotToolbar_Dark_Yellow=Dark Yellow
		69	ScreenshotToolbar_Dash=Dashed line
		70	ScreenshotToolbar_Dash_Dot=1 dots dashed line
		71	ScreenshotToolbar_Dash_Dot2=2 dots dashed line
		72	ScreenshotToolbar_Dot=Dotted line
		73	ScreenshotToolbar_Select_Color=Select Color
		74	ScreenshotToolbar_Select_Rectangle=Select Rectangle
		75	ScreenshotToolbar_Solid=Solid line
		76	ScreenshotToolbar_Fit=Fit
		77	ScreenshotToolbar_Gray=Gray
		78	ScreenshotToolbar_Green=Green
		79	ScreenshotToolbar_Magenta=Magenta
		80	ScreenshotToolbar_White=White
		81	ScreenshotToolbar_Yellow=Yellow
		82	ScreenshotToolbar_ZoomHalf=50%
		83	ScreenshotToolbar_Zoom1X=100%
		84	ScreenshotToolbar_Zoom2X=200%
		85	ScreenshotToolbar_Zoom4X=400%
		86	ScreenshotToolbar_Zoom8X=800%

Lines 55-64 Link Here

(-)src/org/eclipse/mylyn/internal/commons/ui/Messages.java (+110 lines)
55		55
56	public static String ScreenshotCreationPage_Change_pen_color;	56	public static String ScreenshotCreationPage_Change_pen_color;
57		57
		58	public static String ScreenshotCreationPage_Change_text_font;
		59
58	public static String ScreenshotCreationPage_Clear_all_annotations_made_on_screenshot_image;	60	public static String ScreenshotCreationPage_Clear_all_annotations_made_on_screenshot_image;
59		61
60	public static String ScreenshotCreationPage_Clear_Annotations;	62	public static String ScreenshotCreationPage_Clear_Annotations;
61		63
		64	public static String ScreenshotCreationPage_Clear;
		65
		66	public static String ScreenshotCreationPage_Undo;
		67
		68	public static String ScreenshotCreationPage_Undo_annotation;
		69
		70	public static String ScreenshotCreationPage_Redo;
		71
		72	public static String ScreenshotCreationPage_Redo_annotation;
		73
62	public static String ScreenshotCreationPage_Crop;	74	public static String ScreenshotCreationPage_Crop;
63		75
64	public static String ScreenshotCreationPage_Crop_R;	76	public static String ScreenshotCreationPage_Crop_R;
Lines 69-73 Link Here
69		81
70	public static String ScreenshotCreationPage_Fit_Image_F;	82	public static String ScreenshotCreationPage_Fit_Image_F;
71		83
		84	public static String ScreenshotCreationPage_Font_Bold;
		85
		86	public static String ScreenshotCreationPage_Font_Italic;
		87
		88	public static String ScreenshotCreationPage_Font_Name_Size;
		89
72	public static String ScreenshotCreationPage_NOTE_THAT_YOU_CONTINUTE;	90	public static String ScreenshotCreationPage_NOTE_THAT_YOU_CONTINUTE;
		91
		92	public static String ScreenshotToolbar_1dot;
		93
		94	public static String ScreenshotToolbar_2dots;
		95
		96	public static String ScreenshotToolbar_4dots;
		97
		98	public static String ScreenshotToolbar_8dots;
		99
		100	public static String ScreenshotToolbar_Clipboard;
		101
		102	public static String ScreenshotToolbar_Custom;
		103
		104	public static String ScreenshotToolbar_Cyan;
		105
		106	public static String ScreenshotToolbar_Desktop;
		107
		108	public static String ScreenshotToolbar_File;
		109
		110	public static String ScreenshotToolbar_Black;
		111
		112	public static String ScreenshotToolbar_Blue;
		113
		114	public static String ScreenshotToolbar_Box;
		115
		116	public static String ScreenshotToolbar_RBox;
		117
		118	public static String ScreenshotToolbar_Red;
		119
		120	public static String ScreenshotToolbar_Oval;
		121
		122	public static String ScreenshotToolbar_FillBox;
		123
		124	public static String ScreenshotToolbar_FillRBox;
		125
		126	public static String ScreenshotToolbar_FillOval;
		127
		128	public static String ScreenshotToolbar_Free;
		129
		130	public static String ScreenshotToolbar_Line;
		131
		132	public static String ScreenshotToolbar_Text;
		133
		134	public static String ScreenshotToolbar_Dark_Blue;
		135
		136	public static String ScreenshotToolbar_Dark_Cyan;
		137
		138	public static String ScreenshotToolbar_Dark_Gray;
		139
		140	public static String ScreenshotToolbar_Dark_Green;
		141
		142	public static String ScreenshotToolbar_Dark_Magenta;
		143
		144	public static String ScreenshotToolbar_Dark_Red;
		145
		146	public static String ScreenshotToolbar_Dark_Yellow;
		147
		148	public static String ScreenshotToolbar_Dash;
		149
		150	public static String ScreenshotToolbar_Dash_Dot;
		151
		152	public static String ScreenshotToolbar_Dash_Dot2;
		153
		154	public static String ScreenshotToolbar_Dot;
155
156	public static String ScreenshotToolbar_Select_Color;
157
158	public static String ScreenshotToolbar_Select_Rectangle;
159
160	public static String ScreenshotToolbar_Solid;
161
162	public static String ScreenshotToolbar_Fit;
163
164	public static String ScreenshotToolbar_Gray;
165
166	public static String ScreenshotToolbar_Green;
167
168	public static String ScreenshotToolbar_Magenta;
169
170	public static String ScreenshotToolbar_White;
171
172	public static String ScreenshotToolbar_Yellow;
173
174	public static String ScreenshotToolbar_ZoomHalf;
175
176	public static String ScreenshotToolbar_Zoom1X;
177
178	public static String ScreenshotToolbar_Zoom2X;
179
180	public static String ScreenshotToolbar_Zoom4X;
181
182	public static String ScreenshotToolbar_Zoom8X;
73	}	183	}




/*******************************************************************************
 * Copyright (c) 2009 Tasktop Technologies 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
 *
 * Contributors:
 *     Hiroyuki Inaba - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylyn.internal.provisional.commons.ui;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.mylyn.internal.commons.ui.Messages;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.dnd.ImageTransfer;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.ColorDialog;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.FontDialog;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;

public class ScreenshotToolbar extends Composite {

	private class Group {

		private final ToolBar toolbar;

		protected int kind;

		private final int[] kinds;

		private ToolItem[] items;

		private boolean isColorBar;

		public Group(Composite parent, int style, int initKind, int[] kinds, String[] labels,
				ImageDescriptor[] imageDescriptors) {
			toolbar = new ToolBar(parent, SWT.FLAT | SWT.HORIZONTAL | SWT.WRAP);
			GridData gd = new GridData();
			gd.widthHint = gd.minimumWidth = 48;
			toolbar.setLayoutData(gd);

			if ((style >> 16) == SWT.COLOR_LIST_SELECTION) {
				isColorBar = true;
				style = style & 0x00ffff;
			}

			this.kind = initKind;
			this.kinds = kinds;
			setItems(style, kinds, labels, imageDescriptors);
		}

		public ToolBar getToolBar() {
			return toolbar;
		}

		public void setKind(int kind) {
			this.kind = kind;
		}

		public int getKind() {
			return kind;
		}

		public void setEnabled(int kind, boolean enabled) {
			for (int n = 0; n < kinds.length; n++) {
				if (-1 == kind) {
					if (kinds[n] != -1) {
						items[n].setEnabled(enabled);
					}
				} else if (kinds[n] == kind) {
					items[n].setEnabled(enabled);
					break;
				}
			}
		}

		public boolean isEnabled(int kind) {
			for (int n = 0; n < kinds.length; n++) {
				if (kinds[n] == kind) {
					return items[n].isEnabled();
				}
			}
			return false;
		}

		public void setToolTipText(int kind, String label) {
			for (int n = 0; n < kinds.length; n++) {
				if (kinds[n] == kind) {
					items[n].setToolTipText(label);
					break;
				}
			}
		}

		public boolean getSelection(int kind) {
			for (int n = 0; n < kinds.length; n++) {
				if (kinds[n] == kind) {
					return items[n].getSelection();
				}
			}
			return false;
		}

		public void setSelection(int kind, boolean selection) {
			for (int n = 0; n < kinds.length; n++) {
				if (kinds[n] == kind) {
					items[n].setSelection(selection);
					return;
				}
			}
		}

		public void selected(String label) {
			for (int n = 0; n < kinds.length; n++) {
				String toolTipText = items[n].getToolTipText();
				if (toolTipText == null) {
					continue;
				}
				if (toolTipText.equals(label)) {
					items[n].setSelection(true);
					kind = kinds[n];
					if (kind == 255 && isColorBar) {
						kind = kinds[n - 1];
						ColorDialog colorWindow = new ColorDialog(getShell());
						colorWindow.setRGB(int2rgb(kind));
						RGB rgb = colorWindow.open();
						if (rgb != null) {
							Color color = new Color(getDisplay(), rgb);
							Image image = new Image(getDisplay(), 16, 12);
							GC colorGC = new GC(image);
							colorGC.setBackground(color);
							colorGC.fillRectangle(0, 0, 16, 12);
							colorGC.dispose();
							items[n - 1].setImage(image);
							kind = kinds[n - 1] = rgb2int(rgb);
							items[n - 1].setSelection(true);
							items[n].setSelection(false);
						}
					}
				} else {
					if ((items[n].getStyle() & SWT.CHECK) != 0 || (items[n].getStyle() & SWT.RADIO) != 0) {
						items[n].setSelection(false);
					}
				}
			}
		}

		public ToolItem[] getToolItems() {
			return items;
		}

		private void setItems(int style, int[] kinds, String[] labels, ImageDescriptor[] imageDescriptors) {

			Listener listener = new Listener() {

				public void handleEvent(Event event) {
					selected(((ToolItem) (event.widget)).getToolTipText());
				}

			};
			int n;
			items = new ToolItem[kinds.length];
			for (n = 0; n < kinds.length; n++) {
				if ((n & 0x01) != 0) {
					ToolItem item = new ToolItem(toolbar, SWT.SEPARATOR);
					item.setWidth(2);
					item.setControl(new Label(toolbar, SWT.NONE));
				}
				if (kinds[n] == -1) {
					items[n] = new ToolItem(toolbar, SWT.CHECK);
					items[n].setEnabled(false);
				} else {
					items[n] = new ToolItem(toolbar, style);
					items[n].setToolTipText(labels[n]);
					if (imageDescriptors != null && imageDescriptors[n] != null) {
						items[n].setImage(imageDescriptors[n].createImage());
					} else {
						if (isColorBar) {
							Color color = null;
							if (kinds[n + 1] == 255) {
								color = new Color(toolbar.getDisplay(), int2rgb(kinds[n]));
							} else {
								color = toolbar.getDisplay().getSystemColor(kinds[n]);
							}
							Image image = new Image(toolbar.getDisplay(), 16, 12);
							GC colorGC = new GC(image);
							colorGC.setBackground(color);
							colorGC.fillRectangle(0, 0, 16, 12);
							colorGC.dispose();
							items[n].setImage(image);
						} else {
							if (labels[n] != null) {
								items[n].setText(labels[n]);
							}
						}
					}
					if (style == SWT.CHECK || style == SWT.RADIO) {
						if (kind == kinds[n]) {
							items[n].setSelection(true);
						}
					}
					items[n].addListener(SWT.Selection, listener);
				}
			}
		}
	}

	private final Shell shell;

	private Composite dummyComposite;

	private Label separator1;

	private Label separator2;

	private Label separator3;

	private Label separator4;

	// captureGroup
	public enum Capture {
		CAPTURE, CLIPBOARD, FILE, CUT;

		public static Capture paseInt(int intValue) {
			Capture[] values = values();
			for (Capture value : values) {
				if (value.hashCode() == intValue) {
					return value;
				}
			}
			return null;
		}
	}

	private final Group captureGroup;

	// clearGroup
	public enum Clear {
		CLEAR, UNDO, REDO;

		public static Clear paseInt(int intValue) {
			Clear[] values = values();
			for (Clear value : values) {
				if (value.hashCode() == intValue) {
					return value;
				}
			}
			return null;
		}
	}

	private final Group undoGroup;

	// toolGroup
	public enum Tool {
		TEXT, RECT, DRAW, ZOOM;

		public static Tool paseInt(int intValue) {
			Tool[] values = values();
			for (Tool value : values) {
				if (value.hashCode() == intValue) {
					return value;
				}
			}
			return null;
		}
	};

	private final Group toolGroup;

	private String filename;

	// zoomGroup
	public enum Zoom {
		FIT, ZOOM1X, ZOOM2X, ZOOM4X, ZOOM8X, ZOOMHALF;

		public static Zoom paseInt(int intValue) {
			Zoom[] values = values();
			for (Zoom value : values) {
				if (value.hashCode() == intValue) {
					return value;
				}
			}
			return null;
		}
	};

	// drawGroup
	public enum Draw {
		FREE, LINE, BOX, RBOX, OVAL, FILL_BOX, FILL_RBOX, FILL_OVAL;

		public static Draw paseInt(int intValue) {
			Draw[] values = values();
			for (Draw value : values) {
				if (value.hashCode() == intValue) {
					return value;
				}
			}
			return null;
		}
	}

	private Group drawGroup;

	private int drawSavedKind;

	// widthGroup
	private Group widthGroup;

	private int widthSavedKind;

	// zoomGroup
	private Group zoomGroup;

	private int zoomSavedKind;

	// styleGroup
	private Group styleGroup;

	private int styleSavedKind;

	// colorGroup
	private Group colorGroup;

	private int colorSavedKind;

	private int colorCustom;

	// fontLabel
	private Label fontLabel;

	private Font fontCustom;

	private RGB fontRGB;

	public ScreenshotToolbar(Composite parent, int style) {
		super(parent, style);
		shell = parent.getShell();

		GridLayout layout = new GridLayout(1, false);
		layout.marginWidth = 1;
		layout.marginHeight = 1;
		layout.horizontalSpacing = 1;
		layout.verticalSpacing = 1;
		setLayout(layout);

		captureGroup = new Group(this, SWT.PUSH, 0, //
				new int[] { Capture.CAPTURE.hashCode(), //
						Capture.CUT.hashCode(), //
						Capture.CLIPBOARD.hashCode(), //
						Capture.FILE.hashCode() }, // kinds
				new String[] { Messages.ScreenshotToolbar_Desktop, //
						Messages.ScreenshotCreationPage_Crop, //
						Messages.ScreenshotToolbar_Clipboard, //
						Messages.ScreenshotToolbar_File }, // labels
				new ImageDescriptor[] { CommonImages.IMAGE_CAPTURE, //
						CommonImages.CUT, //
						CommonImages.CLIPBOARD_OBJ, //
						CommonImages.FILE_OBJ }) { // images
			@Override
			public void selected(String label) {
				super.selected(label);

				if (kind == Capture.FILE.hashCode()) {
					FileDialog dialog = new FileDialog(shell);
					dialog.setFileName(filename);
					dialog.setFilterExtensions(new String[] { "*.bmp;*.jpg;*.png", "*.*" }); //$NON-NLS-1$ //$NON-NLS-2$
					String result = dialog.open();
					if (result != null && result.length() > 0) {
						filename = result;
						run(Capture.paseInt(kind));
					}
				} else {
					run(Capture.paseInt(kind));
				}
			}
		};
		//captureGroup.setEnabled(Capture.CLIPBOARD.hashCode(), isClipboardImage());

		undoGroup = new Group(this, SWT.PUSH, 0, //
				new int[] { Clear.CLEAR.hashCode(), //
						-1, //
						Clear.UNDO.hashCode(), //
						Clear.REDO.hashCode() }, // kinds
				new String[] { Messages.ScreenshotCreationPage_Clear, //
						null, //
						Messages.ScreenshotCreationPage_Undo, //
						Messages.ScreenshotCreationPage_Redo }, // labels
				new ImageDescriptor[] { CommonImages.CLEAR, //
						null, //
						CommonImages.EDIT_UNDO, //
						CommonImages.EDIT_REDO }) { // images
			@Override
			public void selected(String label) {
				super.selected(label);
				run(Clear.paseInt(undoGroup.getKind()));
			}
		};

		createSeparator();

		toolGroup = new Group(this, SWT.RADIO, Tool.DRAW.hashCode(), //
				new int[] { Tool.DRAW.hashCode(), //
						Tool.TEXT.hashCode(), //
						Tool.RECT.hashCode(), //
						Tool.ZOOM.hashCode() }, // kinds
				new String[] { Messages.ScreenshotCreationPage_Annotate, //
						Messages.ScreenshotToolbar_Text, //
						Messages.ScreenshotToolbar_Select_Rectangle, //
						Messages.ScreenshotCreationPage_Fit_Image }, // labels 
				new ImageDescriptor[] { CommonImages.EDIT, //
						CommonImages.EDIT_TEXT, //
						CommonImages.SEL_RECT, //
						CommonImages.FIND }) { // images
			@Override
			public void selected(String label) {
				super.selected(label);

				if (kind == Tool.ZOOM.hashCode()) {
					createZoomToolBars();
				} else if (kind == Tool.RECT.hashCode()) {
					createRectToolBars();
				} else if (kind == Tool.TEXT.hashCode()) {
					createTextToolBars();
				} else {
					createDrawToolBars();
				}
				toolGroup.getToolBar().getParent().layout();
				selectedTool(Tool.paseInt(kind));
			}
		};

		createSeparator();

		drawSavedKind = Draw.FREE.hashCode();
		widthSavedKind = 4;
		zoomSavedKind = Zoom.FIT.hashCode();
		styleSavedKind = SWT.LINE_SOLID;
		colorCustom = rgb2int(255, 85, 85);
		colorSavedKind = colorCustom;

		FontData[] fontdata = getShell().getFont().getFontData();
		fontdata[0].height *= 2;
		fontCustom = new Font(getDisplay(), fontdata);
		fontRGB = new RGB(255, 0, 0);
		toolGroup.setToolTipText(Tool.TEXT.hashCode(), getMarkFontInfo());

		createDrawToolBars();
	}

	private static int rgb2int(RGB rgb) {
		return rgb2int(rgb.red, rgb.green, rgb.blue);
	}

	private static int rgb2int(int r, int g, int b) {
		return (r << 16) + (g << 8) + b;
	}

	private static RGB int2rgb(int rgb) {
		return new RGB(rgb >> 16, (rgb >> 8) & 0x00ff, rgb & 0x00ff);
	}

	private Label createSeparator() {
		Label label = new Label(this, SWT.SEPARATOR | SWT.HORIZONTAL);
		GridData gd = new GridData();
		gd.widthHint = gd.minimumWidth = 48;
		gd.heightHint = gd.minimumHeight = 1;
		label.setLayoutData(gd);
		return label;
	}

	private void createDummyComposite() {
		dummyComposite = new Composite(this, SWT.NONE);
		GridData gd = new GridData(GridData.FILL_VERTICAL);
		gd.widthHint = gd.minimumWidth = 48;
		dummyComposite.setLayoutData(gd);
	}

	private void disposeDynamicToolBars() {
		if (dummyComposite != null) {
			dummyComposite.dispose();
			dummyComposite = null;
		}
		if (zoomGroup != null) {
			zoomSavedKind = zoomGroup.getKind();
			zoomGroup.getToolBar().dispose();
			zoomGroup = null;
		}
		if (drawGroup != null) {
			drawSavedKind = drawGroup.getKind();
			drawGroup.getToolBar().dispose();
			drawGroup = null;
		}
		if (widthGroup != null) {
			widthSavedKind = widthGroup.getKind();
			widthGroup.getToolBar().dispose();
			widthGroup = null;
		}
		if (styleGroup != null) {
			styleSavedKind = styleGroup.getKind();
			styleGroup.getToolBar().dispose();
			styleGroup = null;
		}
		if (colorGroup != null) {
			colorSavedKind = colorGroup.getKind();
			colorGroup.getToolBar().dispose();
			colorGroup = null;
		}
		if (fontLabel != null) {
			fontLabel.dispose();
			fontLabel = null;
		}

		if (separator1 != null) {
			separator1.dispose();
			separator1 = null;
		}
		if (separator2 != null) {
			separator2.dispose();
			separator2 = null;
		}
		if (separator3 != null) {
			separator3.dispose();
			separator3 = null;
		}
		if (separator4 != null) {
			separator4.dispose();
			separator4 = null;
		}
	}

	private void createRectToolBars() {
		disposeDynamicToolBars();

		createDummyComposite();
	}

	private void createTextToolBars() {
		if (fontLabel != null) {
			return;
		}

		disposeDynamicToolBars();

		fontLabel = new Label(this, SWT.NONE);
		GridData gd = new GridData();
		gd.widthHint = gd.minimumWidth = 47;
		gd.heightHint = gd.minimumHeight = gd.widthHint * 5 / 2;
		fontLabel.setLayoutData(gd);
		fontLabel.setText("abc"); //$NON-NLS-1$
		fontLabel.setFont(fontCustom);
		fontLabel.setForeground(new Color(getDisplay(), fontRGB));
		fontLabel.setToolTipText(getMarkFontInfo());
		toolGroup.setToolTipText(Tool.TEXT.hashCode(), getMarkFontInfo());
		fontLabel.addMouseListener(new MouseListener() {

			public void mouseDoubleClick(MouseEvent e) {
				// None
			}

			public void mouseDown(MouseEvent e) {
				final FontDialog fontWindow = new FontDialog(getShell());
				fontWindow.setFontList(fontCustom.getFontData());
				fontWindow.setRGB(fontRGB);
				FontData fontData = fontWindow.open();
				if (fontData != null) {
					fontRGB = fontWindow.getRGB();
					fontCustom = new Font(getDisplay(), new FontData[] { fontData });
					fontLabel.setToolTipText(getMarkFontInfo());
					fontLabel.setFont(fontCustom);
					fontLabel.setForeground(new Color(getDisplay(), fontRGB));
					fontLabel.setToolTipText(getMarkFontInfo());
					toolGroup.setToolTipText(Tool.TEXT.hashCode(), getMarkFontInfo());
					selectedFont(fontCustom, fontRGB);
				}
			}

			public void mouseUp(MouseEvent e) {
				// None
			}

		});

		separator1 = createSeparator();

		createDummyComposite();
	}

	private String getMarkFontInfo() {
		if (fontCustom == null) {
			return Messages.ScreenshotCreationPage_Change_text_font;
		}
		FontData[] fd = fontCustom.getFontData();
		String info = NLS.bind(Messages.ScreenshotCreationPage_Font_Name_Size, //
				new Object[] { fd[0].getName(), fd[0].getHeight() + "" }); //$NON-NLS-1$
		int style = fd[0].getStyle();
		if ((style & SWT.BOLD) != 0) {
			info = info + Messages.ScreenshotCreationPage_Font_Bold;
		}
		if ((style & SWT.ITALIC) != 0) {
			info = info + Messages.ScreenshotCreationPage_Font_Italic;
		}
		return info;
	}

	private void createZoomToolBars() {
		if (zoomGroup != null) {
			return;
		}

		disposeDynamicToolBars();

		zoomGroup = new Group(this, SWT.RADIO, zoomSavedKind, //
				new int[] { Zoom.FIT.hashCode(), //
						Zoom.ZOOMHALF.hashCode(), //
						Zoom.ZOOM1X.hashCode(), //
						Zoom.ZOOM2X.hashCode(), //
						Zoom.ZOOM4X.hashCode(), //
						Zoom.ZOOM8X.hashCode() }, // kinds
				new String[] { Messages.ScreenshotToolbar_Fit, //
						Messages.ScreenshotToolbar_ZoomHalf, //
						Messages.ScreenshotToolbar_Zoom1X, //
						Messages.ScreenshotToolbar_Zoom2X, //
						Messages.ScreenshotToolbar_Zoom4X, //
						Messages.ScreenshotToolbar_Zoom8X }, // labels
				new ImageDescriptor[] { CommonImages.ZOOM_FIT, //
						CommonImages.ZOOM_HALF, //
						CommonImages.ZOOM_1X, //
						CommonImages.ZOOM_2X, //
						CommonImages.ZOOM_4X, //
						CommonImages.ZOOM_8X }) { // images

			@Override
			public void selected(String label) {
				super.selected(label);
				selectedZoom(Zoom.paseInt(kind));
			}
		};

		separator1 = createSeparator();

		createDummyComposite();
	}

	private void createDrawToolBars() {
		if (drawGroup != null) {
			return;
		}

		disposeDynamicToolBars();

		drawGroup = new Group(this, SWT.RADIO, drawSavedKind, //
				new int[] { Draw.FREE.hashCode(), //
						Draw.LINE.hashCode(), //
						Draw.FILL_BOX.hashCode(), //
						Draw.BOX.hashCode(), //
						Draw.FILL_RBOX.hashCode(), //
						Draw.RBOX.hashCode(), //
						Draw.FILL_OVAL.hashCode(), //
						Draw.OVAL.hashCode() }, // kinds
				new String[] { Messages.ScreenshotToolbar_Free, //
						Messages.ScreenshotToolbar_Line, //
						Messages.ScreenshotToolbar_FillBox, //
						Messages.ScreenshotToolbar_Box, //
						Messages.ScreenshotToolbar_FillRBox, //
						Messages.ScreenshotToolbar_RBox, //
						Messages.ScreenshotToolbar_FillOval, //
						Messages.ScreenshotToolbar_Oval }, // labels 
				new ImageDescriptor[] { CommonImages.EDIT_FREE, //
						CommonImages.EDIT_LINE, //
						CommonImages.EDIT_FILL_BOX, //
						CommonImages.EDIT_BOX, //
						CommonImages.EDIT_FILL_RBOX, //
						CommonImages.EDIT_RBOX, //
						CommonImages.EDIT_FILL_OVAL, //
						CommonImages.EDIT_OVAL }) { // images
			@Override
			public void selected(String label) {
				super.selected(label);

				styleGroup.setEnabled(-1, kind == Draw.LINE.hashCode() || kind == Draw.BOX.hashCode()
						|| kind == Draw.RBOX.hashCode() || kind == Draw.OVAL.hashCode());
				selectedDrawTool(Draw.paseInt(kind));
			}
		};

		separator1 = createSeparator();

		widthGroup = new Group(this, SWT.RADIO, widthSavedKind, //
				new int[] { 1, 2, 4, 8 }, // kinds
				new String[] { Messages.ScreenshotToolbar_1dot, //
						Messages.ScreenshotToolbar_2dots, //
						Messages.ScreenshotToolbar_4dots, //
						Messages.ScreenshotToolbar_8dots }, // labels
				new ImageDescriptor[] { CommonImages.LINE_BOLD1, //
						CommonImages.LINE_BOLD2, //
						CommonImages.LINE_BOLD4, //
						CommonImages.LINE_BOLD8 }) { // images
			@Override
			public void selected(String label) {
				super.selected(label);

				selectedLineWidth(kind);
			}
		};

		separator2 = createSeparator();

		styleGroup = new Group(this, SWT.RADIO, styleSavedKind, //
				new int[] { SWT.LINE_SOLID, //
						SWT.LINE_DOT, //
						SWT.LINE_DASH, //
						SWT.LINE_DASHDOT, //
						SWT.LINE_DASHDOTDOT }, // kinds
				new String[] { Messages.ScreenshotToolbar_Solid, //
						Messages.ScreenshotToolbar_Dot, //
						Messages.ScreenshotToolbar_Dash, //
						Messages.ScreenshotToolbar_Dash_Dot, //
						Messages.ScreenshotToolbar_Dash_Dot2 }, // labels 
				new ImageDescriptor[] { CommonImages.LINE_SOLD, //
						CommonImages.LINE_DOT, //
						CommonImages.LINE_DASH, //
						CommonImages.LINE_DASH1D, //
						CommonImages.LINE_DASH2D }) { // images
			@Override
			public void selected(String label) {
				super.selected(label);

				selectedLineStyle(kind);
			}
		};
		styleGroup.setEnabled(-1, drawSavedKind != Draw.FREE.hashCode());

		separator3 = createSeparator();

		colorGroup = new Group(this, SWT.RADIO | (SWT.COLOR_LIST_SELECTION << 16), colorSavedKind, //
				new int[] { SWT.COLOR_RED, SWT.COLOR_DARK_RED, //
						SWT.COLOR_GREEN, SWT.COLOR_DARK_GREEN, //
						SWT.COLOR_YELLOW, SWT.COLOR_DARK_YELLOW, //
						SWT.COLOR_BLUE, SWT.COLOR_DARK_BLUE, //
						SWT.COLOR_MAGENTA, SWT.COLOR_DARK_MAGENTA, //
						SWT.COLOR_CYAN, SWT.COLOR_DARK_CYAN, //
						SWT.COLOR_GRAY, SWT.COLOR_DARK_GRAY, //
						SWT.COLOR_WHITE, SWT.COLOR_BLACK, //
						colorCustom, 255 //
				}, // kinds
				new String[] { Messages.ScreenshotToolbar_Red, Messages.ScreenshotToolbar_Dark_Red, //
						Messages.ScreenshotToolbar_Green, Messages.ScreenshotToolbar_Dark_Green, //
						Messages.ScreenshotToolbar_Yellow, Messages.ScreenshotToolbar_Dark_Yellow, //
						Messages.ScreenshotToolbar_Blue, Messages.ScreenshotToolbar_Dark_Blue, //
						Messages.ScreenshotToolbar_Magenta, Messages.ScreenshotToolbar_Dark_Magenta, //
						Messages.ScreenshotToolbar_Cyan, Messages.ScreenshotToolbar_Dark_Cyan, //
						Messages.ScreenshotToolbar_Gray, Messages.ScreenshotToolbar_Dark_Gray, //
						Messages.ScreenshotToolbar_White, Messages.ScreenshotToolbar_Black, //
						Messages.ScreenshotToolbar_Custom, Messages.ScreenshotToolbar_Select_Color //
				}, // labels 
				new ImageDescriptor[] { null, null, // Red
						null, null, // Yellow
						null, null, // Green
						null, null, // Magenta
						null, null, // Cyan
						null, null, // Blue
						null, null, // Gray
						null, null, // White
						null, CommonImages.SEL_COLOR // Custom
				} // images
		) {

			@Override
			public void selected(String label) {
				// ignore
				super.selected(label);

				if (kind > 255) {
					colorCustom = kind;
					selectedColor(int2rgb(kind));
				} else {
					selectedColor(getDisplay().getSystemColor(kind).getRGB());
				}
			}

		};

		separator4 = createSeparator();

		createDummyComposite();
	}

	public void run(Capture action) {
	}

	public void run(Clear action) {
	}

	public void selectedLineWidth(int kind) {
	}

	public void selectedTool(Tool tool) {
	}

	public void selectedLineStyle(int kind) {
	}

	public void selectedZoom(Zoom zoom) {
	}

	public void selectedColor(RGB rgb) {
	}

	public void selectedFont(Font font, RGB rgb) {
	}

	public void selectedDrawTool(Draw drawtool) {
	}

	public void setEnabled(Capture kind, boolean enabled) {
		if (kind == null) {
			captureGroup.setEnabled(-1, enabled);
		} else {
			captureGroup.setEnabled(kind.hashCode(), enabled);
		}
	}

	public void setEnabled(Clear kind, boolean enabled) {
		if (kind == null) {
			undoGroup.setEnabled(-1, enabled);
		} else {
			undoGroup.setEnabled(kind.hashCode(), enabled);
		}
	}

	public void setEnabled(Tool kind, boolean enabled) {
		if (kind == null) {
			toolGroup.setEnabled(-1, enabled);
		} else {
			toolGroup.setEnabled(kind.hashCode(), enabled);
		}
		if (toolGroup.getKind() == Tool.DRAW.hashCode()) {
			drawGroup.setEnabled(-1, enabled);
			widthGroup.setEnabled(-1, enabled);
			styleGroup.setEnabled(-1, enabled);
			colorGroup.setEnabled(-1, enabled);
		}
	}

	public int getLineBold() {
		if (widthGroup == null) {
			return widthSavedKind;
		}
		return widthGroup.getKind();
	}

	public int getLineStyle() {
		if (styleGroup == null) {
			return styleSavedKind;
		}
		return styleGroup.getKind();
	}

	public Zoom getZoom() {
		if (zoomGroup == null) {
			return Zoom.paseInt(zoomSavedKind);
		}
		return Zoom.paseInt(zoomGroup.getKind());
	}

	public Tool getTool() {
		return Tool.paseInt(toolGroup.getKind());
	}

	public Draw getDrawTool() {
		if (drawGroup == null) {
			return Draw.paseInt(drawSavedKind);
		}
		return Draw.paseInt(drawGroup.getKind());
	}

	public RGB getDrawColor() {
		int kind = colorSavedKind;
		if (colorGroup != null) {
			kind = colorGroup.getKind();
		}
		if (kind > 255) {
			return int2rgb(colorCustom);
		}
		return getDisplay().getSystemColor(kind).getRGB();
	}

	public Font getTextFont() {
		return fontCustom;
	}

	public RGB getTextColor() {
		return fontRGB;
	}

	public Image getFileImage() {
		try {
			Image image = new Image(shell.getDisplay(), filename);
			return image;
		} catch (Exception e) {
			// None
		}
		return null;
	}

	public Image getClipboardImage() {
		try {
			Clipboard clipboard = new Clipboard(shell.getDisplay());
			ImageTransfer imageTransfer = ImageTransfer.getInstance();
			Object data = clipboard.getContents(imageTransfer);
			if (data instanceof ImageData) {
				Image image = new Image(shell.getDisplay(), (ImageData) data);
				return image;
			}
		} catch (Exception e) {
			// None
		}
		return null;
	}

//	public boolean isClipboardImage() {
//		try {
//			Clipboard clipboard = new Clipboard(shell.getDisplay());
//			ImageTransfer imageTransfer = ImageTransfer.getInstance();
//			Object data = clipboard.getContents(imageTransfer);
//			if (data instanceof ImageData) {
//				return true;
//			}
//		} catch (Exception e) {
//			// None
//		}
//		return false;
//	}

}

Return to bug 266123