Editors.ImageViewerEditor = Image Viewer

      <editor

            id="org.eclipse.ui.internal.ide.ImageViewerEditor"

            class="org.eclipse.ui.internal.imageviewer.ImageViewerEditor"

            icon="$nl$/icons/full/obj16/image_editor.gif"

            default="true"

            name="%Editors.ImageViewerEditor"

            extensions="gif,jpg,jpeg,png,ico,bmp"/>

/*******************************************************************************

 * Copyright (c) 2007 IBM Corporation 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:

 *     Eugene Kuleshov - initial API and implementation (bug 155323)

 *******************************************************************************/

package org.eclipse.ui.internal.imageviewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.ControlAdapter;

import org.eclipse.swt.events.ControlEvent;

import org.eclipse.swt.events.MouseAdapter;

import org.eclipse.swt.events.MouseEvent;

import org.eclipse.swt.events.MouseMoveListener;

import org.eclipse.swt.events.PaintEvent;

import org.eclipse.swt.events.PaintListener;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Cursor;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.graphics.ImageData;

import org.eclipse.swt.graphics.PaletteData;

import org.eclipse.swt.widgets.Canvas;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.ScrollBar;

/**

 * TODO

 * 

 * @since 3.3

 */

public class ImageCanvas extends Canvas {

  private Image image;

  private int clientw;

  private int clienth;

  private int imagex;

  private int imagey;

  private int imagew;

  private int imageh;

  private int scrolly;

  private int scrollx;

  private int mousex;

  private int mousey;

  private Color backgroundColor;

  private boolean listenForMouseMovement = false;

  private Cursor cursorHand;

  private Cursor cursorArrow;

  private double zoomScale = 1;

  /**

   * TODO

   * 

   * @param parent

   * @param style

   */

  public ImageCanvas(Composite parent, int style) {

    super(parent, style | SWT.NO_BACKGROUND | SWT.V_SCROLL | SWT.H_SCROLL);

    backgroundColor = getDisplay().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND);

    cursorHand = new Cursor(getDisplay(), SWT.CURSOR_HAND);

    cursorArrow = new Cursor(getDisplay(), SWT.CURSOR_ARROW);

    this.addControlListener(new ControlAdapter() {

      public void controlResized(ControlEvent e) {

        updateCanvas();

      }

    });

    this.addMouseListener(new MouseAdapter() {

      public void mouseDown(MouseEvent e) {

        listenForMouseMovement = true;

        mousex = e.x;

        mousey = e.y;

        setCursor(cursorHand);

      }

      public void mouseUp(MouseEvent e) {

        listenForMouseMovement = false;

        setCursor(cursorArrow);

      }

    });

    this.addMouseMoveListener(new MouseMoveListener() {

      public void mouseMove(MouseEvent e) {

        if (listenForMouseMovement) {

          followMouse(e);

        }

      }

    });

    this.addPaintListener(new PaintListener() {

      public void paintControl(PaintEvent event) {

        paint(event.gc);

      }

    });

    getHorizontalBar().setEnabled(true);

    getHorizontalBar().addSelectionListener(new SelectionAdapter() {

      public void widgetSelected(SelectionEvent event) {

        updateHorizontalScroll((ScrollBar) event.widget);

      }

    });

    getVerticalBar().setEnabled(true);

    getVerticalBar().addSelectionListener(new SelectionAdapter() {

      public void widgetSelected(SelectionEvent event) {

        updateVerticalScroll((ScrollBar) event.widget);

      }

    });

  }

  /**

   * TODO

   * 

   * @param image

   */

  public void setImage(Image image) {

    if (this.image != null) {

      image.dispose();

    }

    this.image = image;

    updateCanvas();

  }

  /**

   * TODO

   */

  public void zoomFit() {

    zoomScale = 0;

  }

  /**

   * TODO

   */

  public void zoomIn() {

    zoomScale *= 2;

  }

  /**

   * TODO

   */

  public void zoomOut() {

    zoomScale /= 2;

  }

  /**

   * TODO

   */

  public void zoomOriginal() {

    zoomScale = 1;

  }

  public void dispose() {

    super.dispose();

    if (image != null && !image.isDisposed()) {

      image.dispose();

    }

  }

  /**

   * TODO

   */

  public void rotate() {

    ImageData originalData = image.getImageData();

    PaletteData originalPalette = originalData.palette;

    ImageData tmpData;

    PaletteData tmpPalette;

    if (originalPalette.isDirect)

      tmpPalette = new PaletteData(originalPalette.redMask,

          originalPalette.greenMask, originalPalette.blueMask);

    else

      tmpPalette = new PaletteData(originalPalette.getRGBs());

    tmpData = new ImageData(originalData.height, originalData.width,

        originalData.depth, tmpPalette);

    tmpData.transparentPixel = originalData.transparentPixel;

    for (int i = 0; i < originalData.width; i++) {

      for (int k = 0; k < originalData.height; k++) {

        tmpData.setPixel(k, originalData.width - 1 - i, originalData.getPixel(

            i, k));

      }

    }

    if (image != null) {

      image.dispose();

    }

    image = new Image(getDisplay(), tmpData);

    updateCanvas();

  }

  private void updateCanvas() {

    clientw = getClientArea().width;

    clienth = getClientArea().height;

    if (clientw < 1) {

      clientw = 1;

    }

    if (clienth < 1) {

      clienth = 1;

    }

    if (image == null) {

      return;

    }

    imageh = image.getBounds().height;

    imagew = image.getBounds().width;

    updateScrollVisibility();

    getVerticalBar().setSelection(0);

    getHorizontalBar().setSelection(0);

    imagex = clientw / 2 - imagew / 2;

    imagey = clienth / 2 - imageh / 2;

    if (imagex < 0) {

      imagex = 0;

    }

    if (imagey < 0) {

      imagey = 0;

    }

    scrollx = getHorizontalBar().getSelection();

    scrolly = getVerticalBar().getSelection();

    ScrollBar vertical = getVerticalBar();

    vertical.setMaximum(imageh);

    vertical.setThumb(Math.min(clienth, imageh));

    vertical.setIncrement(40);

    vertical.setPageIncrement(clienth);

    ScrollBar horizontal = getHorizontalBar();

    horizontal.setMaximum(imagew);

    horizontal.setThumb(Math.min(clientw, imagew));

    horizontal.setIncrement(40);

    horizontal.setPageIncrement(clientw);

    redraw();

  }

  private void followMouse(MouseEvent e) {

    if (clientw < imagew) {

      int mouseDiffX = (mousex - e.x);

      mousex = e.x;

      imagex -= mouseDiffX;

      getHorizontalBar().setSelection(

          getHorizontalBar().getSelection() + mouseDiffX);

      int minx = clientw - imagew;

      int maxx = 0;

      if (imagex < minx) {

        imagex = minx;

      }

      if (imagex > maxx) {

        imagex = maxx;

      }

      scrollx = getHorizontalBar().getSelection();

    }

    if (clienth < imageh) {

      int mouseDiffY = (mousey - e.y);

      mousey = e.y;

      imagey -= mouseDiffY;

      getVerticalBar().setSelection(

          getVerticalBar().getSelection() + mouseDiffY);

      int miny = clienth - imageh;

      int maxy = 0;

      if (imagey < miny) {

        imagey = miny;

      }

      if (imagey > maxy) {

        imagey = maxy;

      }

      scrolly = getVerticalBar().getSelection();

    }

    redraw();

  }

  void paint(GC gc) {

    Image backImage = new Image(getDisplay(), clientw, clienth);

    GC backGC = new GC(backImage);

    backGC.setBackground(backgroundColor);

    backGC.setClipping(getClientArea());

    backGC.fillRectangle(getClientArea());

    if (image != null) {

      backGC.drawImage(image, imagex, imagey);

    }

    gc.drawImage(backImage, 0, 0);

    backGC.dispose();

    backImage.dispose();

  }

  private void updateScrollVisibility() {

    getHorizontalBar().setVisible(clientw < imagew);

    getVerticalBar().setVisible(clienth < imageh);

  }

  private void updateVerticalScroll(ScrollBar bar) {

    imagey -= bar.getSelection() - scrolly;

    scrolly = bar.getSelection();

    redraw();

  }

  private void updateHorizontalScroll(ScrollBar bar) {

    imagex -= bar.getSelection() - scrollx;

    scrollx = bar.getSelection();

    redraw();

  }

}

/*******************************************************************************

 * Copyright (c) 2007 IBM Corporation 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:

 *     Eugene Kuleshov - initial API and implementation (bug 155323)

 *******************************************************************************/

package org.eclipse.ui.internal.imageviewer;

import java.text.MessageFormat;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.jface.action.IStatusLineManager;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.DisposeEvent;

import org.eclipse.swt.events.DisposeListener;

import org.eclipse.swt.events.FocusEvent;

import org.eclipse.swt.events.FocusListener;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.graphics.ImageData;

import org.eclipse.swt.layout.FillLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.IStorageEditorInput;

import org.eclipse.ui.part.EditorPart;

/**

 * TODO

 * 

 * @since 3.3

 */

public class ImageViewerEditor extends EditorPart {

  private ImageCanvas imageCanvas;

  private Image image;

  public void createPartControl(final Composite parent) {

    final IEditorInput editorInput = getEditorInput();

    setPartName(editorInput.getName());

    new Job("Loading image") { //$NON-NLS-1$

      protected IStatus run(IProgressMonitor monitor) {

        if (editorInput instanceof IStorageEditorInput) {

          IStorageEditorInput storageEditorInput = (IStorageEditorInput) editorInput;

          try {

            image = new Image(parent.getDisplay(), storageEditorInput

                .getStorage().getContents());

            parent.getDisplay().asyncExec(new Runnable() {

              public void run() {

                imageCanvas.setImage(image);

                updateStatus();

              }

            });

          } catch (CoreException ex) {

            // show the error

          }

        }

        return Status.OK_STATUS;

      }

    }.schedule();

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

    composite.setLayout(new FillLayout());

    composite.addFocusListener(new FocusListener() {

      public void focusGained(FocusEvent e) {

        updateStatus();

      }

      public void focusLost(FocusEvent e) {

        IStatusLineManager statusLineManager = getEditorSite().getActionBars()

            .getStatusLineManager();

        statusLineManager.setMessage(""); //$NON-NLS-1$

      }

    });

    this.imageCanvas = new ImageCanvas(composite, SWT.NONE);

    parent.addDisposeListener(new DisposeListener() {

      public void widgetDisposed(DisposeEvent e) {

        if (imageCanvas != null && !imageCanvas.isDisposed()) {

          imageCanvas.dispose();

        }

        if (image != null && !image.isDisposed()) {

          image.dispose();

        }

      }

    });

  }

  public void setPartName(String partName) {

    super.setPartName(partName);

  }

  public void init(IEditorSite site, IEditorInput input) {

    setSite(site);

    setInput(input);

  }

  public void setFocus() {

    if (imageCanvas != null) {

      imageCanvas.setFocus();

    }

    updateStatus();

  }

  public void doSave(IProgressMonitor monitor) {

  }

  public void doSaveAs() {

  }

  public boolean isDirty() {

    return false;

  }

  public boolean isSaveAsAllowed() {

    return false;

  }

  private void updateStatus() {

    if (image != null) {

      ImageData data = image.getImageData();

      MessageFormat mf = new MessageFormat("{0} | size: {1} x {2} | depth: {3}"); //$NON-NLS-1$

      String message = mf.format(new Object[] {getPartName(), new Integer(data.width), new Integer(data.height), new Integer(data.depth)});

      IStatusLineManager statusLineManager = getEditorSite().getActionBars()

          .getStatusLineManager();

      statusLineManager.setMessage(message);

    }

  }

}