EDIT

/**

 * Copyright (C) 2007 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.ui.element;

import java.io.IOException;

import java.io.InputStream;

import java.net.URI;

import org.apache.http.HttpException;

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.e4.ui.model.application.ui.basic.MPart;

import org.eclipse.e4.ui.workbench.modeling.EPartService;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.swt.events.PaintEvent;

import org.eclipse.swt.events.PaintListener;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Event;

import org.eclipse.ui.forms.widgets.TableWrapData;

import eu.etaxonomy.cdm.common.UriUtils;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.view.e4.AbstractCdmDataViewerE4;

import eu.etaxonomy.taxeditor.view.e4.details.DetailsPartE4;

import eu.etaxonomy.taxeditor.view.e4.supplementaldata.SupplementalDataPartE4;

/**

 * @author n.hoffmann

 * @created Sep 24, 2010

 * @version 1.0

 */

public class ImageElement extends AbstractCdmFormElement implements PaintListener{

    /**

     * @author pplitzner

     * @since Jul 17, 2019

     *

     */

    public class LoadImageJob extends Job {

        public LoadImageJob(String name) {

            super(name);

        }

        @Override

        protected IStatus run(IProgressMonitor monitor) {

            IRunnableWithProgress runnable = getLoadImageRunnable(postRunnable);

            try {

                runnable.run(monitor);

            } catch (Exception e) {

                MessagingUtils.messageDialog("Could not load image", getClass(), e.getMessage()  + ": " +  getImageUri(), e);

            }

            return Status.OK_STATUS;

        }

    }

    private URI imageUri;

    private Image image;

    private Composite container;

    private final Runnable postRunnable = new Runnable(){

        @Override

        public void run() {

            try{

                EPartService partService = getFormFactory().getContext().get(EPartService.class);

                DetailsPartE4 detailsView = AbstractUtility.getDetailsView(partService);

                if(detailsView!=null){

                    AbstractCdmDataViewerE4 viewer = (AbstractCdmDataViewerE4) detailsView.getViewer();

                    if(viewer!=null){

                        viewer.reflow();

                    }

                }

                MPart mPartSupplemental = partService.findPart("eu.etaxonomy.taxeditor.view.e4.supplementaldata.SupplementalDataPartE4");

                if(mPartSupplemental!=null){

                    SupplementalDataPartE4 supplementalPart = (SupplementalDataPartE4)mPartSupplemental.getObject();

                    if(supplementalPart!=null){

                        AbstractCdmDataViewerE4 viewer = (AbstractCdmDataViewerE4) (supplementalPart).getViewer();

                        if(viewer!=null){

                            viewer.refresh();

                        }

                    }

                }

            }

            catch(IllegalStateException e){

                //when migrating to E4 this execption should not be thrown anymore

            }

        }

    };

    protected ImageElement(CdmFormFactory formFactory, ICdmFormElement parentElement, URI imageUri, int style) {

        super(formFactory, parentElement);

        container = new Composite(getLayoutComposite(), style);

        container.setLayoutData(LayoutConstants.FILL(2, 1));

        container.addPaintListener(this);

    }

    public void initImageUri(URI uri) throws IOException, HttpException {

        this.imageUri = uri;

        InputStream imageStream = UriUtils.getInputStream(imageUri);

        image = new Image(Display.getCurrent(), imageStream);

    }

    public URI getImageUri() {

        return imageUri;

    }

    public void loadImage(){

        if(getImageUri() != null){

            Job job = new LoadImageJob("Loading image");

            job.schedule();

        }

    }

    public IRunnableWithProgress getLoadImageRunnable(final Runnable postRunnable){

        final Display display = getLayoutComposite().getDisplay();

        IRunnableWithProgress runnable = new IRunnableWithProgress(){

            @Override

            public void run(IProgressMonitor monitor) {

                monitor.beginTask("Loading: " + getImageUri(), IProgressMonitor.UNKNOWN);

                // redraw the image container

                display.asyncExec(new Runnable(){

                    @Override

                    public void run() {

                        if(! getLayoutComposite().isDisposed() && container!=null){

                            Event untypedEvent = new Event();

                            untypedEvent.widget = container;

                            PaintEvent event = new PaintEvent(untypedEvent);

                            event.gc = new GC(container);

                            paintControl(event);

                            getLayoutComposite().layout();

                        }

                    }

                });

                // execute the external runnable

                if(postRunnable != null){

                    display.asyncExec(postRunnable);

                }

                monitor.done();

            }

        };

        return runnable;

    }

    private Rectangle calculateImageBounds(Image image, Control control){

        Rectangle imageBounds = image.getBounds();

        Rectangle containerBounds = control.getBounds();

        Integer imgWidth = imageBounds.width;

        Integer imgHeight = imageBounds.height;

        Float ratio = imgHeight.floatValue()/imgWidth.floatValue();

        Integer width = containerBounds.width;

        Integer height = ((Float) (width * ratio)).intValue();

        return new Rectangle(containerBounds.x, containerBounds.y, width, height);

    }

    public void dispose(){

        if(image!=null){

            image.dispose();

            image = null;

        }

        imageUri = null;

        if(container!=null){

            container.dispose();

            container = null;

        }

    }

    /** {@inheritDoc} */

    @Override

    public void paintControl(PaintEvent e) {

        TableWrapData layoutData = LayoutConstants.FILL(2, 1);

        Control control = (Control) e.widget;

        if(image != null){

            Rectangle imageMaxBounds = calculateImageBounds(image, control);

            layoutData.heightHint = imageMaxBounds.height;

            e.gc.drawImage(image, 0, 0, image.getBounds().width, image.getBounds().height, 0, 0, imageMaxBounds.width, imageMaxBounds.height);

        }else{

            layoutData.heightHint = 10;

            e.gc.drawRectangle(0, 0, 0, 10);

        }

        control.setLayoutData(layoutData);

        e.gc.dispose();

    }

}