DiagramGraphicalViewer.java

/******************************************************************************
 * Copyright (c) 2002, 2010 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:
 *    IBM Corporation - initial API and implementation 
 ****************************************************************************/

package org.eclipse.gmf.runtime.diagram.ui.parts;

import java.util.List;

import org.eclipse.draw2d.DeferredUpdateManager;
import org.eclipse.draw2d.LightweightSystem;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer;
import org.eclipse.gmf.runtime.common.ui.util.DisplayUtils;
import org.eclipse.gmf.runtime.diagram.ui.internal.parts.ElementToEditPartsMap;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.TransferDragSourceListener;
import org.eclipse.jface.util.TransferDropTargetListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.widgets.Display;

/**
 * @author melaasar
 * @author Aurelien Pupier: remove resourceManager as implemented by superclass (bug 180171)
 * 
 * Implementation of a diagram graphical viewer
 */
public class DiagramGraphicalViewer
    extends ScrollingGraphicalViewer
    implements IDiagramGraphicalViewer {
 
    /**
     * Constructor
     */
    public DiagramGraphicalViewer() {
        super();
    }

    /**
     * @param enable
     *            <code>boolean</code> <code>true</code> if client wishes to
     *            disable updates on the figure canvas, <code>false</code>
     *            indicates normal updates are to take place.
     */
    public void enableUpdates(boolean enable) {
        if (enable)
            getLightweightSystemWithUpdateToggle().enableUpdates();
        else
            getLightweightSystemWithUpdateToggle().disableUpdates();
    }
    
    /**
     * @return
     */
    public boolean areUpdatesDisabled() {
        return getLightweightSystemWithUpdateToggle().getToggleUpdateManager().shouldDisableUpdates();
    }

    private class ToggleUpdateManager
        extends DeferredUpdateManager {

        private boolean disableUpdates = false;

        /**
         * @return the disableUpdates
         */
        public boolean shouldDisableUpdates() {
            return disableUpdates;
        }

        /* (non-Javadoc)
         * @see org.eclipse.draw2d.DeferredUpdateManager#sendUpdateRequest()
         */
        protected void sendUpdateRequest() {
            DisplayUtils.getDisplay().asyncExec(new UpdateRequest());
        }

        /**
         * @param disableUpdates
         *            the disableUpdates to set
         */
        public synchronized void setDisableUpdates(boolean disableUpdates) {
            boolean prevDisableUpdates = this.disableUpdates;
            this.disableUpdates = disableUpdates;
            if (!disableUpdates && prevDisableUpdates != disableUpdates) {
                sendUpdateRequest();
            }
        }

        /*
         * (non-Javadoc)
         * 
         * @see org.eclipse.draw2d.DeferredUpdateManager#performUpdate()
         */
        public synchronized void performUpdate() {
            if (!shouldDisableUpdates())
                super.performUpdate();
        }

        /*
         * (non-Javadoc)
         * 
         * @see org.eclipse.draw2d.DeferredUpdateManager#performValidation()
         */
        public void performValidation() {
            if (!shouldDisableUpdates())
                super.performValidation();
        }
        
        /* (non-Javadoc)
         * @see org.eclipse.draw2d.DeferredUpdateManager#queueWork()
         */
        public void queueWork() {
            if (!shouldDisableUpdates())
                super.queueWork();
        }
    }

    private class LightweightSystemWithUpdateToggle
        extends LightweightSystem {

        /*
         * (non-Javadoc)
         * 
         * @see org.eclipse.draw2d.LightweightSystem#getUpdateManager()
         */
        public ToggleUpdateManager getToggleUpdateManager() {
            return (ToggleUpdateManager) getUpdateManager();
        }

        /**
         * disable updates on the figure canvas
         */
        public void disableUpdates() {
            getToggleUpdateManager().setDisableUpdates(true);
        }

        /**
         * allow updates on the figure canvas to occcur
         */
        public void enableUpdates() {
            getToggleUpdateManager().setDisableUpdates(false);
        }
    }

    private LightweightSystemWithUpdateToggle getLightweightSystemWithUpdateToggle() {
        return (LightweightSystemWithUpdateToggle) getLightweightSystem();
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.gef.ui.parts.GraphicalViewerImpl#createLightweightSystem()
     */
    protected LightweightSystem createLightweightSystem() {
        LightweightSystem lws = new LightweightSystemWithUpdateToggle();
        lws.setUpdateManager(new ToggleUpdateManager());
        return lws;
    }

    /**
     * A selection event pending flag (for asynchronous firing)
     */
    private boolean selectionEventPending = false;

    /**
     * A registry of editparts on the diagram, mapping an element's id string to
     * a list of <code>EditParts</code>.
     */
    private ElementToEditPartsMap elementToEditPartsMap = new ElementToEditPartsMap();

    /**
     * Hook a zoom enabled graphics source
     * 
     * @see org.eclipse.gef.ui.parts.AbstractEditPartViewer#hookControl()
     */
    protected void hookControl() {
        super.hookControl();        
    }

    /**
     * Refresh drag source adapters regardless if the adapter list is empty
     * 
     * @see org.eclipse.gef.ui.parts.AbstractEditPartViewer#removeDragSourceListener(TransferDragSourceListener)
     */
    public void removeDragSourceListener(TransferDragSourceListener listener) {
        getDelegatingDragAdapter().removeDragSourceListener(listener);
        refreshDragSourceAdapter();
    }

    /**
     * Refresh drag target adapters regardless if the adapter list is empty
     * 
     * @see org.eclipse.gef.ui.parts.AbstractEditPartViewer#removeDropTargetListener(TransferDropTargetListener)
     */
    public void removeDropTargetListener(TransferDropTargetListener listener) {
        getDelegatingDropAdapter().removeDropTargetListener(listener);
        refreshDropTargetAdapter();
    }

    /**
     * Overriden to also flush pending selection events to account for OS
     * diffences, since we are firing selection change events asynchronously.
     */
    public void flush() {
        super.flush();
        if (selectionEventPending) {
            flushSelectionEvents(getSelection());
        }

    }

    /**
     * For performance reasons, we fire the event asynchronously
     */
    protected void fireSelectionChanged() {
        if (selectionEventPending)
            return;
        selectionEventPending = true;
        Display display = DisplayUtils.getDisplay();
        if (display != null) {
            display.asyncExec(new Runnable() {

                public void run() {
                    flushSelectionEvents(getSelection());
                }
            });
        }
    }

    /**
     * flush the selection events
     * 
     * @param sel
     */
    protected void flushSelectionEvents(ISelection sel) {
        selectionEventPending = false;
        SelectionChangedEvent event = new SelectionChangedEvent(this, sel);

        // avoid exceptions caused by selectionChanged
        // modifiying selectionListeners
        Object[] array = selectionListeners.toArray();

        for (int i = 0; i < array.length; i++) {
            ISelectionChangedListener l = (ISelectionChangedListener) array[i];
            if (selectionListeners.contains(l))
                l.selectionChanged(event);
        }
    }

    private void fireEmptySelection() {
        if (selectionEventPending)
            return;
        selectionEventPending = true;
        Display display = getControl().getDisplay();
        if (display != null) {
            display.asyncExec(new Runnable() {

                public void run() {
                    flushSelectionEvents(getSelection());
                    flushSelectionEvents(StructuredSelection.EMPTY);
                }
            });
        }
    }

    /**
     * @see org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramGraphicalViewer#getDiagramEditDomain()
     */
    public IDiagramEditDomain getDiagramEditDomain() {
        return (IDiagramEditDomain) getEditDomain();
    }

    /**
     * @see org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramGraphicalViewer#findEditPartsForElement(java.lang.String,
     *      java.lang.Class)
     */
    public List findEditPartsForElement(String elementIdStr, Class editPartClass) {
        return elementToEditPartsMap.findEditPartsForElement(elementIdStr,
            editPartClass);
    }

    /**
     * @see org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramGraphicalViewer#registerEditPartForElement(java.lang.String,
     *      org.eclipse.gef.EditPart)
     */
    public void registerEditPartForElement(String elementIdStr, EditPart ep) {
        elementToEditPartsMap.registerEditPartForElement(elementIdStr, ep);
    }

    /**
     * @see org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramGraphicalViewer#unregisterEditPartForElement(java.lang.String,
     *      org.eclipse.gef.EditPart)
     */
    public void unregisterEditPartForElement(String elementIdStr, EditPart ep) {
        elementToEditPartsMap.unregisterEditPartForElement(elementIdStr, ep);
    }

    /** The work space preference store */
    private IPreferenceStore workspacePreferenceStore;

    private boolean initializing;

    /**
     * The editor manages the workspaces preferences store. So viewers not using
     * a editor do not need to create a preference store. This method provides a
     * hook for clients requiring access to the preference store.
     * 
     * @param store
     */
    public void hookWorkspacePreferenceStore(IPreferenceStore store) {
        this.workspacePreferenceStore = store;
    }

    /**
     * Returns the workspace preference store managed by the
     * <code>DiagramEditor</code>, if one is being used. May return null.
     * 
     * @return the work space preference store
     */
    public IPreferenceStore getWorkspaceViewerPreferenceStore() {
        return workspacePreferenceStore;
    }
  
    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.gef.ui.parts.AbstractEditPartViewer#unhookControl()
     */
    protected void unhookControl() {
        fireEmptySelection();
        super.unhookControl();
    }

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.gef.ui.parts.AbstractEditPartViewer#setContents(org.eclipse.gef.EditPart)
     */
    public void setContents(EditPart editpart) {
        initializing = true;
        try {
            super.setContents(editpart);
        } finally {
            initializing = false;
        }
    }

    /**
     * checks if the viewer is still in the process of initializing itself
     * 
     * @return true if initializing; false if the initializing process is
     *         finished
     */
    public boolean isInitializing() {
        return initializing;
    }
}