/**
 * Copyright (c) 2007, 2020 THALES GLOBAL SERVICES and others.
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *    Obeo - initial API and implementation
 *
 */
package org.eclipse.sirius.diagram.ui.provider;

import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.emf.common.EMFPlugin;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.ui.EclipseUIPlugin;
import org.eclipse.emf.common.util.ResourceLocator;
import org.eclipse.emf.ecore.provider.EcoreEditPlugin;
import org.eclipse.emf.ecore.provider.EcoreItemProviderAdapterFactory;
import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
import org.eclipse.emf.edit.provider.IItemLabelProvider;
import org.eclipse.emf.edit.provider.INotifyChangedListener;
import org.eclipse.emf.edit.provider.ReflectiveItemProviderAdapterFactory;
import org.eclipse.emf.edit.provider.resource.ResourceItemProviderAdapterFactory;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider;
import org.eclipse.emf.edit.ui.provider.ExtendedImageRegistry;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint;
import org.eclipse.gmf.runtime.draw2d.ui.figures.PolylineConnectionEx;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.DecorationOverlayIcon;
import org.eclipse.jface.viewers.IDecoration;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.sirius.common.ui.tools.internal.preference.DynamicConfigurationHelper;
import org.eclipse.sirius.diagram.description.concern.provider.ConcernItemProviderAdapterFactory;
import org.eclipse.sirius.diagram.description.filter.provider.FilterItemProviderAdapterFactory;
import org.eclipse.sirius.diagram.provider.DiagramItemProviderAdapterFactory;
import org.eclipse.sirius.diagram.ui.api.layout.CustomLayoutAlgorithm;
import org.eclipse.sirius.diagram.ui.business.internal.image.ImageSelectorDescriptorRegistryListener;
import org.eclipse.sirius.diagram.ui.business.internal.image.refresh.WorkspaceImageFigureRefresher;
import org.eclipse.sirius.diagram.ui.internal.layout.CustomLayoutAlgorithmProviderRegistry;
import org.eclipse.sirius.diagram.ui.internal.refresh.listeners.WorkspaceFileResourceChangeListener;
import org.eclipse.sirius.diagram.ui.tools.api.decoration.SiriusDecorationProviderRegistry;
import org.eclipse.sirius.diagram.ui.tools.api.preferences.SiriusDiagramUiPreferencesKeys;
import org.eclipse.sirius.diagram.ui.tools.internal.decoration.DescribedDecorationDescriptorProvider;
import org.eclipse.sirius.diagram.ui.tools.internal.decoration.EditModeDecorationDescriptorProvider;
import org.eclipse.sirius.diagram.ui.tools.internal.decoration.SubDiagramDecorationDescriptorProvider;
import org.eclipse.sirius.diagram.ui.tools.internal.decoration.ValidationDecorationDescriptorProvider;
import org.eclipse.sirius.diagram.ui.tools.internal.format.data.extension.FormatDataManagerRegistryListener;
import org.eclipse.sirius.diagram.ui.tools.internal.resource.CustomSiriusDocumentProvider;
import org.eclipse.sirius.diagram.ui.tools.internal.resource.ResourceMissingDocumentProvider;
import org.eclipse.sirius.viewpoint.description.audit.provider.AuditItemProviderAdapterFactory;
import org.eclipse.sirius.viewpoint.description.validation.provider.ValidationItemProviderAdapterFactory;
import org.eclipse.sirius.viewpoint.provider.SiriusEditPlugin;
import org.eclipse.sirius.viewpoint.provider.ViewpointItemProviderAdapterFactory;
import org.eclipse.swt.graphics.Image;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.osgi.framework.BundleContext;

/**
 * This is the central singleton for the Diagram edit plugin. <!-- begin-user-doc --> <!-- end-user-doc -->
 *
 * @generated-not
 */
public final class DiagramUIPlugin extends EMFPlugin {

    private static final String DECORATOR_CHECK_PATH = "icons/full/decorator/active.gif"; //$NON-NLS-1$

    public static final String ID = "org.eclipse.sirius.diagram.ui"; //$NON-NLS-1$

    /**
     * @was-generated
     */
    public static final PreferencesHint DIAGRAM_PREFERENCES_HINT = new PreferencesHint(DiagramUIPlugin.ID);

    /**
     * Keep track of the singleton. <!-- begin-user-doc --> <!-- end-user-doc -->
     *
     * @generated
     */
    public static final DiagramUIPlugin INSTANCE = new DiagramUIPlugin();

    /**
     * Keep track of the singleton. <!-- begin-user-doc --> <!-- end-user-doc -->
     *
     * @generated
     */
    private static Implementation plugin;

    /**
     * Create the instance. <!-- begin-user-doc --> <!-- end-user-doc -->
     *
     * @generated
     */
    public DiagramUIPlugin() {
        super(new ResourceLocator[] { EcoreEditPlugin.INSTANCE, SiriusEditPlugin.INSTANCE, });
    }

    /**
     * Returns the singleton instance of the Eclipse plugin. <!-- begin-user-doc --> <!-- end-user-doc -->
     *
     * @return the singleton instance.
     * @generated
     */
    @Override
    public ResourceLocator getPluginResourceLocator() {
        return DiagramUIPlugin.plugin;
    }

    /**
     * Returns the singleton instance of the Eclipse plugin. <!-- begin-user-doc --> <!-- end-user-doc -->
     *
     * @return the singleton instance.
     * @generated
     */
    public static Implementation getPlugin() {
        return DiagramUIPlugin.plugin;
    }

    /**
     * The actual implementation of the Eclipse <b>Plugin</b>. <!-- begin-user-doc --> <!-- end-user-doc -->
     *
     * @generated-not
     */
    public static class Implementation extends EclipseUIPlugin {

        private ComposedAdapterFactory adapterFactory;

        private ILabelProvider labelProvider;

        private Map<ImageWithDimensionDescriptor, Image> descriptorsToImages;

        private ResourceMissingDocumentProvider ressourceMissingDocumentProvider;

        private FormatDataManagerRegistryListener formatDataManagerRegistryListener;

        private ImageSelectorDescriptorRegistryListener imageSelectorDescriptorRegistryListener;

        private WorkspaceImageFigureRefresher workspaceImageFigureRefresher;

        private DynamicDiagramUIPreferences dynamicPreferences;

        /**
         * A registry containing all layout providers that can be specified directly in the VSM. A layout provider
         * provides a layout algorithm that can be used when doing an arrange all on a Sirius diagram.
         */
        private Map<String, CustomLayoutAlgorithm> layoutAlgorithmsRegistry;

        /**
         * A registry updating the {@link Implementation#layoutAlgorithmsRegistry} from extension point declarations.
         */
        private CustomLayoutAlgorithmProviderRegistry layoutAlgorithmProviderRegistry;

        /**
         * Creates an instance. <!-- begin-user-doc --> <!-- end-user-doc -->
         *
         * @generated
         */
        public Implementation() {
            super();

            // Remember the static instance.
            //
            DiagramUIPlugin.plugin = this;
        }

        /**
         * Add a new custom layout algorithm to the registry.
         *
         * @param customLayoutAlgorithm
         *            the layout algorithm to add.
         */
        public void addLayoutAlgorithm(CustomLayoutAlgorithm customLayoutAlgorithm) {
            layoutAlgorithmsRegistry.put(customLayoutAlgorithm.getId(), customLayoutAlgorithm);
        }

        /**
         * Remove the layout algorithm identified by the given id from the registry.
         *
         * @param layoutProviderId
         *            the id of the layout algorithm to remove from the registry.
         * @return the layout algorithm removed if such element exists.
         */
        public CustomLayoutAlgorithm removeLayoutAlgorithm(String layoutProviderId) {
            return layoutAlgorithmsRegistry.remove(layoutProviderId);
        }

        /**
         * Returns the unmodifiable registry containing all layout providers that can be specified directly in the VSM.
         *
         * @return an unmodifiable map of CustomLayoutAlgorithm associated to their id.
         */
        public Map<String, CustomLayoutAlgorithm> getLayoutAlgorithms() {
            return Collections.unmodifiableMap(layoutAlgorithmsRegistry);
        }

        /**
         * Logs an error in the error log.
         *
         * @param message
         *            the message to log (optional).
         * @param e
         *            the exception (optional).
         */
        public void error(final String message, final Exception e) {
            String msgToDisplay = message;
            if (message == null && e != null) {
                msgToDisplay = e.getMessage();
            }
            if (e instanceof CoreException) {
                this.getLog().log(((CoreException) e).getStatus());
            } else {
                final IStatus status = new Status(IStatus.ERROR, this.getBundle().getSymbolicName(), msgToDisplay, e);
                this.getLog().log(status);
            }
        }

        /**
         * @not-generated create the image registry
         */
        @Override
        public void start(BundleContext context) throws Exception {
            super.start(context);
            // By default in Sirius, we don't want to consider the partial jump links. This is a new behavior available
            // in GMF since 1.13.0.
            PolylineConnectionEx.DISABLE_PARTIAL_JUMP_LINKS = true;

            PreferencesHint.registerPreferenceStore(DiagramUIPlugin.DIAGRAM_PREFERENCES_HINT, getPreferenceStore());
            dynamicPreferences = new DynamicDiagramUIPreferences(getPreferenceStore());

            adapterFactory = createAdapterFactory();
            descriptorsToImages = new HashMap<ImageWithDimensionDescriptor, Image>();
            ressourceMissingDocumentProvider = new ResourceMissingDocumentProvider();

            workspaceImageFigureRefresher = new WorkspaceImageFigureRefresher();
            workspaceImageFigureRefresher.init();

            imageSelectorDescriptorRegistryListener = new ImageSelectorDescriptorRegistryListener();
            imageSelectorDescriptorRegistryListener.init();

            formatDataManagerRegistryListener = new FormatDataManagerRegistryListener();
            formatDataManagerRegistryListener.init();

            layoutAlgorithmsRegistry = new HashMap<String, CustomLayoutAlgorithm>();

            layoutAlgorithmProviderRegistry = new CustomLayoutAlgorithmProviderRegistry(layoutAlgorithmsRegistry);
            Platform.getExtensionRegistry().addListener(layoutAlgorithmProviderRegistry, CustomLayoutAlgorithmProviderRegistry.LAYOUT_ALGORITHM_PROVIDER_EXTENSION_POINT_ID);

            registerCoreDecorationProviders();
        }

        private void registerCoreDecorationProviders() {
            SiriusDecorationProviderRegistry.INSTANCE.addSiriusDecorationDescriptorProvider(new DescribedDecorationDescriptorProvider());
            SiriusDecorationProviderRegistry.INSTANCE.addSiriusDecorationDescriptorProvider(new EditModeDecorationDescriptorProvider());
            SiriusDecorationProviderRegistry.INSTANCE.addSiriusDecorationDescriptorProvider(new SubDiagramDecorationDescriptorProvider());
            SiriusDecorationProviderRegistry.INSTANCE.addSiriusDecorationDescriptorProvider(new ValidationDecorationDescriptorProvider());
        }

        private void unregisterDecorationProviders() {
            SiriusDecorationProviderRegistry.INSTANCE.clear();
        }

        /**
         * @not-generated disposing the images
         */
        @Override
        public void stop(BundleContext context) throws Exception {
            try {
                disposeLabelProvider();

                adapterFactory.dispose();
                adapterFactory = null;
            } catch (NullPointerException e) {
                // can occur when using CDO (if the view is
                // closed when transactions have been closed)
            } catch (IllegalStateException e) {
                // can occur when using CDO (if the view is
                // closed when transactions have been closed)
            }
            layoutAlgorithmsRegistry = null;
            formatDataManagerRegistryListener.dispose();
            formatDataManagerRegistryListener = null;

            workspaceImageFigureRefresher.dispose();
            workspaceImageFigureRefresher = null;

            imageSelectorDescriptorRegistryListener.dispose();
            imageSelectorDescriptorRegistryListener = null;

            layoutAlgorithmProviderRegistry = null;
            layoutAlgorithmsRegistry = null;
            /*
             * Disposing the images
             */
            Iterator<Image> it = descriptorsToImages.values().iterator();
            while (it.hasNext()) {
                Image img = it.next();
                if (img != null) {
                    img.dispose();
                }
            }
            /* dispose missing resources creation */
            this.ressourceMissingDocumentProvider.dispose();

            WorkspaceFileResourceChangeListener.getInstance().dispose();

            unregisterDecorationProviders();

            super.stop(context);
        }

        protected void disposeLabelProvider() {
            if (labelProvider instanceof INotifyChangedListener) {
                adapterFactory.removeListener((INotifyChangedListener) labelProvider);
            }
        }

        /**
         * @was-generated NOT use THE mighty factory
         */
        protected ComposedAdapterFactory createAdapterFactory() {
            List<AdapterFactory> factories = new ArrayList<AdapterFactory>();
            factories.add(new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE));
            fillItemProviderFactories(factories);
            return new ComposedAdapterFactory(factories);
        }

        /**
         * Return a new adapter factory.
         *
         * @return A new adapter factory
         */
        public ComposedAdapterFactory getNewAdapterFactory() {
            return createAdapterFactory();
        }

        protected ILabelProvider createLabelProvider() {
            if (labelProvider == null) {
                labelProvider = new AdapterFactoryLabelProvider(getItemProvidersAdapterFactory());
            }
            return labelProvider;
        }

        /**
         * @was-generated
         */
        protected void fillItemProviderFactories(List<AdapterFactory> factories) {
            factories.add(new ViewpointItemProviderAdapterFactory());
            factories.add(new DiagramItemProviderAdapterFactory());

            factories.add(new org.eclipse.sirius.viewpoint.description.provider.DescriptionItemProviderAdapterFactory());
            factories.add(new org.eclipse.sirius.diagram.description.provider.DescriptionItemProviderAdapterFactory());

            factories.add(new org.eclipse.sirius.viewpoint.description.style.provider.StyleItemProviderAdapterFactory());
            factories.add(new org.eclipse.sirius.diagram.description.style.provider.StyleItemProviderAdapterFactory());

            factories.add(new org.eclipse.sirius.viewpoint.description.tool.provider.ToolItemProviderAdapterFactory());
            factories.add(new org.eclipse.sirius.diagram.description.tool.provider.ToolItemProviderAdapterFactory());

            factories.add(new AuditItemProviderAdapterFactory());
            factories.add(new ConcernItemProviderAdapterFactory());
            factories.add(new FilterItemProviderAdapterFactory());
            factories.add(new ValidationItemProviderAdapterFactory());

            factories.add(new EcoreItemProviderAdapterFactory());
            factories.add(new ResourceItemProviderAdapterFactory());
            factories.add(new ReflectiveItemProviderAdapterFactory());
        }

        /**
         * @not-generated : recreate adapter factory if destroyed..
         */
        public AdapterFactory getItemProvidersAdapterFactory() {
            if (adapterFactory == null) {
                adapterFactory = createAdapterFactory();
            }
            return adapterFactory;
        }

        /**
         * Get the default label provider.
         *
         * @return the label provider single instance
         */
        public ILabelProvider getLabelProvider() {
            if (labelProvider == null) {
                createLabelProvider();
            }
            return labelProvider;
        }

        /**
         * @was-generated
         */
        public ImageDescriptor getItemImageDescriptor(Object item) {
            IItemLabelProvider labelProvider = (IItemLabelProvider) adapterFactory.adapt(item, IItemLabelProvider.class);
            if (labelProvider != null) {
                return ExtendedImageRegistry.getInstance().getImageDescriptor(labelProvider.getImage(item));
            }
            return null;
        }

        /**
         * Returns an image descriptor for the image file at the given plug-in relative path.
         *
         * @was-generated
         * @param path
         *            the path
         * @return the image descriptor
         */
        public static ImageDescriptor getBundledImageDescriptor(String path) {
            return AbstractUIPlugin.imageDescriptorFromPlugin(DiagramUIPlugin.ID, path);
        }

        /**
         * Returns an image descriptor for the image file at the given url.
         *
         * @param url
         *            the url
         * @return the image descriptor
         */
        public static ImageDescriptor getURLImageDescriptor(URL url) {
            return ImageDescriptor.createFromURL(url);
        }

        /**
         * Respects images residing in any plug-in. If path is relative, then this bundle is looked up for the image,
         * otherwise, for absolute path, first segment is taken as id of plug-in with image
         *
         * @was-generated
         * @param path
         *            the path to image, either absolute (with plug-in id as first segment), or relative for bundled
         *            images
         * @return the image descriptor
         */
        public static ImageDescriptor findImageDescriptor(String path) {
            final IPath p = new Path(path);
            if (p.isAbsolute() && p.segmentCount() > 1) {
                return AbstractUIPlugin.imageDescriptorFromPlugin(p.segment(0), p.removeFirstSegments(1).makeAbsolute().toString());
            } else {
                return Implementation.getBundledImageDescriptor(p.makeAbsolute().toString());
            }
        }

        /**
         * Respects images residing in any plug-in. If path is relative, then this bundle is looked up for the image,
         * otherwise, for absolute path, first segment is taken as id of plug-in with image
         *
         * @param path
         *            the path to image, either absolute (with plug-in id as first segment), or relative for bundled
         *            images
         * @return the image descriptor
         */
        public static ImageWithDimensionDescriptor findImageWithDimensionDescriptor(String path, final Dimension dimension) {
            ImageDescriptor desc = Implementation.findImageDescriptor(path);
            if (desc != null) {
                return new ImageWithDimensionDescriptorImpl(desc, dimension);
            }
            return null;
        }

        /**
         * Respects images residing in any plug-in. If path is relative, then this bundle is looked up for the image,
         * otherwise, for absolute path, first segment is taken as id of plug-in with image
         *
         * @param path
         *            the path to image, either absolute (with plug-in id as first segment), or relative for bundled
         *            images
         * @return the image descriptor
         */
        public static ImageWithDimensionDescriptor findImageWithDimensionDescriptor(String path) {
            return Implementation.findImageWithDimensionDescriptor(path, ImageWithDimensionDescriptor.NO_RESIZE);
        }

        /**
         * Returns an image descriptor for the image file at the given URL.
         *
         * @param url
         *            the URL.
         * @return the image descriptor.
         */
        public static ImageDescriptor findImageDescriptor(URL url) {
            return Implementation.getURLImageDescriptor(url);
        }

        /**
         * @param imageDescriptor
         * @return the image descriptor with the check decorator
         */
        public static ImageDescriptor getDecoratedCheckedImageDescriptor(final ImageDescriptor imageDescriptor) {
            return Implementation.getDecoratedImageDescriptor(imageDescriptor, DiagramUIPlugin.DECORATOR_CHECK_PATH);
        }

        /**
         * @param image
         * @return the image with the check decorator
         */
        public static Image getDecoratedCheckedImage(final ImageDescriptor imageDescriptor) {
            return Implementation.getDecoratedImage(imageDescriptor, DiagramUIPlugin.DECORATOR_CHECK_PATH);
        }

        /**
         * @param imageDescriptor
         * @param decoratorPath
         * @return the image descriptor decorated
         */
        public static ImageDescriptor getDecoratedImageDescriptor(final ImageDescriptor imageDescriptor, String decoratorPath) {
            if (imageDescriptor != null) {
                return Implementation.getOverlayedDescriptor(DiagramUIPlugin.getPlugin().getImage(imageDescriptor), decoratorPath);
            }
            return imageDescriptor;
        }

        /**
         * @param imagePath
         * @param decoratorPath
         * @return the image descriptor decorated
         */
        public static ImageDescriptor getDecoratedImageDescriptor(final String imagePath, String decoratorPath) {
            return Implementation.getDecoratedImageDescriptor(Implementation.getBundledImageDescriptor(imagePath), decoratorPath);
        }

        /**
         * @param image
         * @param decoratorPath
         * @return the image decorated
         */
        public static Image getDecoratedImage(final ImageDescriptor imageDescriptor, String decoratorPath) {
            Image image = DiagramUIPlugin.getPlugin().getImage(imageDescriptor);
            if (image != null) {
                return DiagramUIPlugin.getPlugin().getImage(Implementation.getOverlayedDescriptor(image, decoratorPath));
            }
            return image;
        }

        /**
         * @param image
         * @param decoratorPath
         * @return the image decorated
         */
        public static Image getDecoratedImage(Image image, String decoratorPath) {
            if (image != null) {
                return DiagramUIPlugin.getPlugin().getImage(Implementation.getOverlayedDescriptor(image, decoratorPath));
            }
            return image;
        }

        private static ImageDescriptor getOverlayedDescriptor(final Image baseImage, final String decoratorPath) {
            final ImageDescriptor decoratorDescriptor = DiagramUIPlugin.Implementation.getBundledImageDescriptor(decoratorPath);
            return new DecorationOverlayIcon(baseImage, decoratorDescriptor, IDecoration.BOTTOM_RIGHT);
        }

        /**
         * Returns an image for the image file at the given plug-in relative path. Client do not need to dispose this
         * image. Images will be disposed automatically.
         *
         * @was-generated
         * @param path
         *            the path
         * @return image instance
         */
        public Image getBundledImage(String path) {
            Image image = getImageRegistry().get(path);
            if (image == null) {
                getImageRegistry().put(path, Implementation.getBundledImageDescriptor(path));
                image = getImageRegistry().get(path);
            }
            return image;
        }

        /**
         *
         * @param desc
         *            an image descriptor.
         * @return an Image instance
         */
        public Image getImage(ImageWithDimensionDescriptor desc) {
            if (!descriptorsToImages.containsKey(desc)) {
                final ImageWithDimensionDescriptor fullSizeDesc = new ImageWithDimensionDescriptorImpl(desc.getImageDescriptor());

                if (descriptorsToImages.containsKey(fullSizeDesc)) {
                    final Image fullSize = descriptorsToImages.get(fullSizeDesc);
                    final ImageDescriptor descToUse = ImageDescriptor.createFromImageData(fullSize.getImageData().scaledTo(desc.getDimension().width, desc.getDimension().height));
                    descriptorsToImages.put(desc, descToUse.createImage());
                } else {
                    descriptorsToImages.put(fullSizeDesc, fullSizeDesc.getImageDescriptor().createImage());
                }
                return getImage(desc);
            }
            return descriptorsToImages.get(desc);
        }

        /**
         *
         * @param desc
         *            an image descriptor.
         * @return an Image instance
         */
        public Image getImage(ImageDescriptor desc) {
            final ImageWithDimensionDescriptor realDesc = new ImageWithDimensionDescriptorImpl(desc);
            if (!descriptorsToImages.containsKey(realDesc)) {
                descriptorsToImages.put(realDesc, desc.createImage());
            }
            return descriptorsToImages.get(realDesc);
        }

        /**
         *
         * @param desc
         *            an image descriptor.
         * @return an Image instance
         */
        public boolean removeCacheImage(ImageDescriptor desc) {
            final ImageWithDimensionDescriptor realDesc = new ImageWithDimensionDescriptorImpl(desc);
            return removeCacheImage(realDesc);
        }

        private boolean removeCacheImage(ImageWithDimensionDescriptor realDesc) {
            return descriptorsToImages.remove(realDesc) != null;
        }

        /**
         * Get the missing resource document provider.
         *
         * @return the single instance to handle missing document
         */
        public ResourceMissingDocumentProvider getResourceMissingDocumentProvider() {
            return this.ressourceMissingDocumentProvider;
        }

        /**
         * @param transactionalEditingDomain
         * @not-generated
         * @since 0.9.0
         */
        public CustomSiriusDocumentProvider getDocumentProvider(TransactionalEditingDomain transactionalEditingDomain) {
            return new CustomSiriusDocumentProvider(transactionalEditingDomain);
        }

        public DynamicDiagramUIPreferences getDynamicPreferences() {
            return dynamicPreferences;
        }

        /**
         * This class is a mean to keep sync with possible changes of the {@link SiriusDiagramUiPreferencesKeys}
         * preferences.
         */
        public class DynamicDiagramUIPreferences extends DynamicConfigurationHelper {
            /**
             * @see SiriusDiagramUiPreferencesKeys.PREF_AUTHORIZE_DECORATION_OVERLAP
             */
            private boolean authorizeDecorationOverlap;

            DynamicDiagramUIPreferences(IPreferenceStore store) {
                super(store);
                bindBoolean(SiriusDiagramUiPreferencesKeys.PREF_AUTHORIZE_DECORATION_OVERLAP.name(), "authorizeDecorationOverlap"); //$NON-NLS-1$
            }

            public boolean authorizeDecorationOverlap() {
                return authorizeDecorationOverlap;
            }
        }
    }

}