org.eclipse.osbp.ecview.extension.editparts.emf/src/org/eclipse/osbp/ecview/extension/editparts/emf/StrategyLayoutEditpart.java

/**
 *                                                                            
 *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
 *                                                                            
 *  All rights reserved. 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:                                                      
 * 	   Florian Pirchner - Initial implementation
 * 
 */
package org.eclipse.osbp.ecview.extension.editparts.emf;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.impl.BasicEObjectImpl;
import org.eclipse.osbp.ecview.core.common.context.IViewContext;
import org.eclipse.osbp.ecview.core.common.editpart.IEmbeddableEditpart;
import org.eclipse.osbp.ecview.core.common.editpart.IKeyStrokeDefinitionEditpart;
import org.eclipse.osbp.ecview.core.common.editpart.emf.EmbeddableEditpart;
import org.eclipse.osbp.ecview.core.common.editpart.validation.IValidatorEditpart;
import org.eclipse.osbp.ecview.core.common.editpart.visibility.IVisibilityProcessorEditpart;
import org.eclipse.osbp.ecview.core.common.model.core.YView;
import org.eclipse.osbp.ecview.core.common.model.visibility.YVisibilityProcessor;
import org.eclipse.osbp.ecview.extension.api.IFocusingEnhancer;
import org.eclipse.osbp.ecview.extension.editparts.IInternalFocusingEditpart;
import org.eclipse.osbp.ecview.extension.editparts.IInternalLayoutingInfoEditpart;
import org.eclipse.osbp.ecview.extension.editparts.ILayoutingInfoEditpart;
import org.eclipse.osbp.ecview.extension.editparts.IStrategyLayoutEditpart;
import org.eclipse.osbp.ecview.extension.editparts.ISuspectEditpart;
import org.eclipse.osbp.ecview.extension.editparts.presentation.IStrategyLayoutPresentation;
import org.eclipse.osbp.ecview.extension.editparts.strategies.IFocusingStrategyEditpart;
import org.eclipse.osbp.ecview.extension.editparts.strategies.ILayoutingStrategyEditpart;
import org.eclipse.osbp.ecview.extension.model.YECviewFactory;
import org.eclipse.osbp.ecview.extension.model.YECviewPackage;
import org.eclipse.osbp.ecview.extension.model.YFocusingStrategy;
import org.eclipse.osbp.ecview.extension.model.YLayoutingInfo;
import org.eclipse.osbp.ecview.extension.model.YLayoutingStrategy;
import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
import org.eclipse.osbp.ecview.extension.model.YSuspect;
import org.eclipse.osbp.runtime.common.keystroke.KeyStrokeCallback;
import org.osgi.framework.BundleContext;
import org.osgi.framework.FrameworkUtil;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceReference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * The implementation of the IStrategyLayoutEditpart.
 */
public class StrategyLayoutEditpart extends EmbeddableEditpart<YStrategyLayout>
		implements IStrategyLayoutEditpart {

	/** The Constant LOGGER. */
	private static final Logger LOGGER = LoggerFactory
			.getLogger(StrategyLayoutEditpart.class);

	/** The suspects. */
	private List<ISuspectEditpart> suspects;

	/** The focusing strategies. */
	private List<IFocusingStrategyEditpart> focusingStrategies;

	/** The layouting strategy. */
	private ILayoutingStrategyEditpart layoutingStrategy;

	/** The layouting info. */
	private ILayoutingInfoEditpart layoutingInfo;

	/** The keystroke callbacks. */
	private HashMap<IFocusingStrategyEditpart, KeyStrokeCallback> keystrokeCallbacks = new HashMap<IFocusingStrategyEditpart, KeyStrokeCallback>();

	/**
	 * Instantiates a new strategy layout editpart.
	 */
	protected StrategyLayoutEditpart() {

	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.osbp.ecview.core.common.editpart.datatypes.IDatatypeEditpart
	 * .DatatypeBridge#getDatatypeValidators()
	 */
	@Override
	public List<IValidatorEditpart> getDatatypeValidators() {
		return Collections.emptyList();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.ecview.extension.editparts.IStrategyLayoutEditpart#
	 * getSuspects()
	 */
	@Override
	public List<ISuspectEditpart> getSuspects() {
		checkDisposed();

		if (suspects == null) {
			internalLoadSuspects();
		}
		return Collections.unmodifiableList(suspects);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.ecview.core.common.editpart.emf.EmbeddableEditpart#
	 * initialize(org.eclipse.osbp.ecview.core.common.model.core.YEmbeddable)
	 */
	@Override
	public void initialize(IViewContext context, YStrategyLayout model) {

		checkDisposed();

		// register the adapter first to find this editpart later...
		EObject eObject = castEObject(model);
		try {
			// avoid delivery during init
			((BasicEObjectImpl) eObject).eSetDeliver(false);
			if (!eObject.eAdapters().contains(this)) {
				eObject.eAdapters().add(this);
			}

			// initialize the default strategies if required
			//
			if (model.getLayoutingStrategy() == null) {
				model.setLayoutingStrategy(YECviewFactory.eINSTANCE
						.createYDefaultLayoutingStrategy());
			}
			this.layoutingStrategy = getEditpart(getContext(),
					model.getLayoutingStrategy());

			if (model.getFocusingStrategies().isEmpty()) {
				enhanceDefaultFocusing(model);
			}

			super.initialize(context, model);
		} finally {
			((BasicEObjectImpl) eObject).eSetDeliver(true);
		}
	}

	protected void registerAdapter(Adapter adapter) {
		// not here!
	}

	protected void checkAdapter(YStrategyLayout model) {
		// not here!
	}

	/**
	 * Enhance default focusing.
	 *
	 * @param model
	 *            the model
	 */
	private void enhanceDefaultFocusing(YStrategyLayout model) {
		IFocusingEnhancer applier = findFocusingEnhancer(model
				.getDefaultFocusingEnhancerId());
		if (applier != null) {
			applier.enhanceFocusing(model);
		}
	}

	/**
	 * Find focusing enhancer.
	 *
	 * @param defaultFocusingEnhancerId
	 *            the default focusing enhancer id
	 * @return the i focusing enhancer
	 */
	private IFocusingEnhancer findFocusingEnhancer(
			String defaultFocusingEnhancerId) {
		if (defaultFocusingEnhancerId != null) {
			return findFocusingEnhancerService(defaultFocusingEnhancerId);
		} else {
			return findDefaultFocusingEnhancerService();
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.ecview.extension.editparts.IStrategyLayoutEditpart#
	 * findFocusingEnhancerService(java.lang.String)
	 */
	public IFocusingEnhancer findFocusingEnhancerService(String id) {
		BundleContext context = FrameworkUtil.getBundle(getClass())
				.getBundleContext();

		try {
			Collection<ServiceReference<IFocusingEnhancer>> references = context
					.getServiceReferences(IFocusingEnhancer.class, String
							.format("(ecview.focusing.enhancer.id=%s)", id));
			if (!references.isEmpty()) {
				IFocusingEnhancer provider = context.getService(references
						.iterator().next());
				return provider;
			}
		} catch (InvalidSyntaxException e) {
			LOGGER.warn("{}", e);
		}
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.ecview.extension.editparts.IStrategyLayoutEditpart#
	 * findDefaultFocusingEnhancerService()
	 */
	public IFocusingEnhancer findDefaultFocusingEnhancerService() {
		BundleContext context = FrameworkUtil.getBundle(getClass())
				.getBundleContext();

		try {
			Collection<ServiceReference<IFocusingEnhancer>> references = context
					.getServiceReferences(IFocusingEnhancer.class,
							"(ecview.focusing.enhancer.default=true)");
			if (!references.isEmpty()) {
				IFocusingEnhancer provider = context.getService(references
						.iterator().next());
				return provider;
			}
		} catch (InvalidSyntaxException e) {
			LOGGER.warn("{}", e);
		}
		return null;
	}

	/**
	 * Clients may override and return a proper default focusing strategy.
	 *
	 * @return the default focusing strategy
	 */
	protected YFocusingStrategy getDefaultFocusingStrategy() {
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.osbp.ecview.core.common.editpart.emf.EmbeddableEditpart#render
	 * (java.lang.Object)
	 */
	@Override
	public Object render(Object parentWidget) {
		if (this.layoutingStrategy != null) {
			// call the layout strategy before rendering -> Will set the content
			this.layoutingStrategy.layout();
		}

		internalActivateLayoutingInfo();

		internalActivateFocusingStrategies();

		Object result = super.render(parentWidget);
		
		internalPostActivateLayoutingInfo();
		
		return result;
	}

	/**
	 * Returns true, if the presenter is present.
	 *
	 * @return true, if is presentation present
	 */
	protected boolean isPresentationPresent() {
		return internalGetPresentation() != null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.ecview.core.common.editpart.emf.EmbeddableEditpart#
	 * getPresentation()
	 */
	@SuppressWarnings("unchecked")
	@Override
	public IStrategyLayoutPresentation<?> getPresentation() {
		return super.getPresentation();
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected void handleModelSet(int featureId, Notification notification) {
		checkDisposed();

		switch (featureId) {
		case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_STRATEGY:
			internalSetLayoutingStrategy((YLayoutingStrategy) notification
					.getNewValue());
			break;
		case YECviewPackage.YSTRATEGY_LAYOUT__LAYOUTING_INFO:
			internalSetLayoutingInfo((YLayoutingInfo) notification
					.getNewValue());
			break;
		case YECviewPackage.YSTRATEGY_LAYOUT__DEFAULT_FOCUSING_ENHANCER_ID:
			enhanceDefaultFocusing(getModel());
			break;
		default:
			super.handleModelSet(featureId, notification);
		}
	}

	/**
	 * Set the new content.
	 *
	 * @param cxInfo
	 *            the cx info
	 */
	protected void internalSetLayoutingInfo(YLayoutingInfo cxInfo) {
		ILayoutingInfoEditpart newEditpart = getEditpart(getContext(), cxInfo);

		if (this.layoutingInfo == newEditpart) {
			return;
		}

		if (this.layoutingInfo != null) {
			getPresentation().setContent(null);
			this.layoutingInfo.dispose();
		}

		this.layoutingInfo = newEditpart;

		if (isRendered()) {
			internalActivateLayoutingInfo();
		}
	}

	/**
	 * Internal activate layouting info.
	 */
	protected void internalActivateLayoutingInfo() {
		if (this.layoutingInfo != null) {
			// refresh the content
			IEmbeddableEditpart contentEP = this.layoutingInfo.getContent();
			getPresentation().setContent(contentEP);

			((IInternalLayoutingInfoEditpart) this.layoutingInfo).activate();

			YView yView = (YView) getView().getModel();
			for (YVisibilityProcessor yP : yView.getVisibilityProcessors()) {
				IVisibilityProcessorEditpart ep = getEditpart(getContext(), yP);
				if (ep != null) {
					ep.fire();
				}
			}
		}
	}

	protected void internalPostActivateLayoutingInfo() {
		if (this.layoutingInfo != null) {
			((IInternalLayoutingInfoEditpart) this.layoutingInfo)
					.postActivate();
		}
	}

	/**
	 * Internal activate focusing strategies.
	 */
	protected void internalActivateFocusingStrategies() {
		for (IFocusingStrategyEditpart strategyEP : getFocusingStrategies()) {
			internalActivateFocusingStrategy(strategyEP);
		}
	}

	/**
	 * Internally activate the focusing strategy.
	 *
	 * @param strategy
	 *            the strategy
	 */
	protected void internalActivateFocusingStrategy(
			final IFocusingStrategyEditpart strategy) {
		if (strategy != null) {
			IKeyStrokeDefinitionEditpart keyStrokeDefEditpart = strategy
					.getKeyStrokeDefinition();

			if (keyStrokeDefEditpart == null) {
				LOGGER.error("Focusing strategy not activated, since missing key stroke definitions. Strategy: "
						+ strategy.getId());
				return;
			}

			KeyStrokeCallback callback = new KeyStrokeCallback() {
				@Override
				public void callback(Object source, Object target) {
					requestFocusing(source, target, strategy);
				}
			};
			keystrokeCallbacks.put(strategy, callback);
			getPresentation().registerKeyStroke(keyStrokeDefEditpart, callback);
			((IInternalFocusingEditpart) strategy).activate();
		}
	}

	/**
	 * Internally deactivate the focusing strategy.
	 *
	 * @param strategy
	 *            the strategy
	 */
	protected void internalDectivateFocusingStrategy(
			final IFocusingStrategyEditpart strategy) {
		if (strategy != null) {
			KeyStrokeCallback callback = keystrokeCallbacks.remove(strategy);
			if (callback != null) {
				getPresentation().unregisterKeyStroke(callback);
			}
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.ecview.extension.editparts.IStrategyLayoutEditpart#
	 * deactivate
	 * (org.eclipse.osbp.ecview.extension.editparts.ILayoutingInfoEditpart)
	 */
	@Override
	public void deactivate(ILayoutingInfoEditpart info) {
		if (info == null || info != this.layoutingInfo) {
			return;
		}
		getModel().setLayoutingInfo(null);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.osbp.ecview.extension.editparts.IStrategyLayoutEditpart#activate
	 * (org.eclipse.osbp.ecview.extension.editparts.ILayoutingInfoEditpart)
	 */
	@Override
	public void activate(ILayoutingInfoEditpart info) {
		getModel().setLayoutingInfo((YLayoutingInfo) info.getModel());
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.ecview.extension.editparts.IStrategyLayoutEditpart#
	 * requestLayouting()
	 */
	@Override
	public void requestLayouting() {
		if (!isRendered()) {
			return;
		}

		if (this.layoutingStrategy != null) {
			// call the layout strategy before rendering -> Will set the content
			this.layoutingStrategy.layout();
		}
	}

	/**
	 * Adds the focusing strategy.
	 *
	 * @param strategy
	 *            the strategy
	 */
	protected void internalAddFocusingStrategy(
			IFocusingStrategyEditpart strategy) {
		checkDisposed();

		if (focusingStrategies == null) {
			internalLoadFocusingStrategies();
		}
		if (!focusingStrategies.contains(strategy)) {
			focusingStrategies.add(strategy);

			if (isRendered()) {
				internalActivateFocusingStrategy(strategy);
			}
		}
	}

	/**
	 * Removes the focusing strategy.
	 *
	 * @param strategy
	 *            the strategy
	 */
	protected void internalRemoveFocusingStrategy(
			IFocusingStrategyEditpart strategy) {
		checkDisposed();

		if (focusingStrategies != null && strategy != null) {

			// deactivate and dispose the strategy
			internalDectivateFocusingStrategy(strategy);
			strategy.dispose();

			focusingStrategies.remove(strategy);
		}
	}

	/**
	 * Set the layout strategy.
	 *
	 * @param cxStrategy
	 *            the cx strategy
	 */
	protected void internalSetLayoutingStrategy(YLayoutingStrategy cxStrategy) {
		ILayoutingStrategyEditpart newEitpart = getEditpart(getContext(),
				cxStrategy);

		if (this.layoutingStrategy != null) {
			layoutingStrategy.dispose();
		}

		this.layoutingStrategy = newEitpart;

		if (this.layoutingStrategy == null) {
			getModel().setLayoutingStrategy(
					YECviewFactory.eINSTANCE.createYDefaultLayoutingStrategy());
		} else {
			this.layoutingStrategy.layout();
		}
	}

	/**
	 * {@inheritDoc}
	 */
	protected void handleModelAdd(int featureId, Notification notification) {
		checkDisposed();

		switch (featureId) {
		case YECviewPackage.YSTRATEGY_LAYOUT__SUSPECTS:
			YSuspect yElement = (YSuspect) notification.getNewValue();

			ISuspectEditpart editPart = (ISuspectEditpart) getEditpart(
					getContext(), yElement);
			internalAddSuspect(editPart);
			break;
		case YECviewPackage.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES:
			IFocusingStrategyEditpart focusingEditPart = (IFocusingStrategyEditpart) getEditpart(
					getContext(),
					(YFocusingStrategy) notification.getNewValue());
			internalAddFocusingStrategy(focusingEditPart);
			break;
		default:
			break;
		}
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected void handleModelMove(int featureId, Notification notification) {
		checkDisposed();

		switch (featureId) {
		case YECviewPackage.YSTRATEGY_LAYOUT__SUSPECTS:
			YSuspect yElement = (YSuspect) notification.getNewValue();

			ISuspectEditpart editPart = (ISuspectEditpart) getEditpart(
					getContext(), yElement);
			internalMoveSuspect(editPart, notification.getPosition());
			break;
		default:
			break;
		}
	}

	/**
	 * {@inheritDoc}
	 */
	protected void handleModelRemove(int featureId, Notification notification) {
		checkDisposed();

		switch (featureId) {
		case YECviewPackage.YSTRATEGY_LAYOUT__SUSPECTS:
			YSuspect yElement = (YSuspect) notification.getOldValue();

			ISuspectEditpart editPart = (ISuspectEditpart) getEditpart(
					getContext(), yElement);
			internalRemoveSuspect(editPart);
			break;
		case YECviewPackage.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES:
			IFocusingStrategyEditpart focusingEditPart = (IFocusingStrategyEditpart) getEditpart(
					getContext(),
					(YFocusingStrategy) notification.getOldValue());
			internalRemoveFocusingStrategy(focusingEditPart);
			break;
		default:
			break;
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.ecview.core.common.editpart.emf.ElementEditpart#
	 * handleModelRemoveMany(int, org.eclipse.emf.common.notify.Notification)
	 */
	protected void handleModelRemoveMany(int featureId,
			Notification notification) {
		checkDisposed();

		switch (featureId) {
		case YECviewPackage.YSTRATEGY_LAYOUT__FOCUSING_STRATEGIES:

			@SuppressWarnings("unchecked")
			List<YFocusingStrategy> oldValues = (List<YFocusingStrategy>) notification
					.getOldValue();
			for (YFocusingStrategy cxFocusingStrategy : oldValues) {
				IFocusingStrategyEditpart focusingEditPart = (IFocusingStrategyEditpart) getEditpart(
						getContext(), cxFocusingStrategy);
				internalRemoveFocusingStrategy(focusingEditPart);
			}
			break;
		default:
			break;
		}
	}

	/**
	 * Is called to change the internal state and add the given editpart to the
	 * list of suspects.
	 * 
	 * @param editpart
	 *            The editpart to be added
	 */
	protected void internalAddSuspect(ISuspectEditpart editpart) {
		checkDisposed();

		if (suspects == null) {
			internalLoadSuspects();
		}
		if (!suspects.contains(editpart)) {
			suspects.add(editpart);
		}
	}

	/**
	 * Is called to change the internal state and to move the given editpart in
	 * the list of suspects.
	 * 
	 * @param editpart
	 *            The editpart to be inserted
	 * @param index
	 *            The index to move the suspect.
	 */
	protected void internalMoveSuspect(ISuspectEditpart editpart, int index) {
		checkDisposed();

		if (suspects == null) {
			internalLoadSuspects();
		} else if (!suspects.contains(editpart)) {
			throw new RuntimeException(String.format(
					"Editpart %s is not contained in elements",
					editpart.getId()));
		} else {
			suspects.remove(editpart);
			suspects.add(index, editpart);
		}
	}

	/**
	 * Is called to change the internal state and remove the given editpart from
	 * the list of suspects.
	 * 
	 * @param editpart
	 *            The editpart to be removed
	 */
	protected void internalRemoveSuspect(ISuspectEditpart editpart) {
		checkDisposed();

		if (suspects != null && editpart != null) {
			suspects.remove(editpart);
		}
	}

	/**
	 * Is called to load and initialize all suspects.
	 */
	protected void internalLoadSuspects() {
		checkDisposed();

		if (suspects == null) {
			suspects = new ArrayList<ISuspectEditpart>();
			for (YSuspect yElement : getModel().getSuspects()) {
				ISuspectEditpart editPart = getEditpart(getContext(), yElement);
				internalAddSuspect(editPart);
			}
		}
	}

	/**
	 * Is called to load and initialize all focusing strategies.
	 */
	protected void internalLoadFocusingStrategies() {
		checkDisposed();

		if (focusingStrategies == null) {
			focusingStrategies = new ArrayList<IFocusingStrategyEditpart>();
			for (YFocusingStrategy yElement : getModel()
					.getFocusingStrategies()) {
				IFocusingStrategyEditpart editPart = getEditpart(getContext(),
						yElement);
				internalAddFocusingStrategy(editPart);
			}
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.ecview.core.common.editpart.emf.EmbeddableEditpart#
	 * internalDispose()
	 */
	@Override
	protected void internalDispose() {
		try {

			LOGGER.info("Disposing " + toString());

			if (layoutingInfo != null) {
				layoutingInfo.dispose();
				layoutingInfo = null;
			}

			// lazy loading: edit parts also have to be disposed if they have
			// not been loaded yet, but exist in the model.
			if (suspects != null || getModel().getSuspects().size() > 0) {
				List<ISuspectEditpart> tempElements = getSuspects();
				synchronized (suspects) {
					for (ISuspectEditpart editpart : tempElements
							.toArray(new ISuspectEditpart[tempElements.size()])) {
						editpart.dispose();
					}
				}
			}
			suspects = null;

			if (layoutingStrategy != null) {
				layoutingStrategy.dispose();
				layoutingStrategy = null;
			}

			if (focusingStrategies != null
					|| getModel().getFocusingStrategies().size() > 0) {
				List<IFocusingStrategyEditpart> tempElements = getFocusingStrategies();
				synchronized (focusingStrategies) {
					for (IFocusingStrategyEditpart editpart : tempElements
							.toArray(new IFocusingStrategyEditpart[tempElements
									.size()])) {
						editpart.dispose();
					}
				}
			}
			focusingStrategies = null;

		} finally {
			super.internalDispose();
		}
	}

	/**
	 * ONLY FOR TESTS!.
	 *
	 * @return the focusingStrategy
	 */
	public List<IFocusingStrategyEditpart> getFocusingStrategies() {
		internalLoadFocusingStrategies();

		return focusingStrategies != null ? Collections
				.unmodifiableList(focusingStrategies) : Collections
				.<IFocusingStrategyEditpart> emptyList();
	}

	/**
	 * ONLY FOR TESTS!.
	 *
	 * @return the layoutingStrategy
	 */
	public ILayoutingStrategyEditpart getLayoutingStrategy() {
		return layoutingStrategy;
	}

	/**
	 * Gets the keystroke callbacks.
	 *
	 * @return the keystrokeCallbacks
	 */
	public HashMap<IFocusingStrategyEditpart, KeyStrokeCallback> getKeystrokeCallbacks() {
		return keystrokeCallbacks;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.ecview.extension.editparts.IStrategyLayoutEditpart#
	 * requestFocusing(java.lang.Object, java.lang.Object,
	 * org.eclipse.osbp.ecview
	 * .extension.editparts.strategies.IFocusingStrategyEditpart)
	 */
	@Override
	public void requestFocusing(Object source, Object target,
			IFocusingStrategyEditpart strategy) {
		strategy.focus(source, target);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.ecview.extension.editparts.IStrategyLayoutEditpart#
	 * requestRefresh(org.eclipse.osbp.ecview.extension.editparts.strategies.
	 * IFocusingStrategyEditpart)
	 */
	@Override
	public void requestRefresh(final IFocusingStrategyEditpart strategy) {
		internalDectivateFocusingStrategy(strategy);
		internalActivateFocusingStrategy(strategy);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.osbp.ecview.extension.editparts.IStrategyLayoutEditpart#
	 * resetToDefaultFocusing()
	 */
	@Override
	public void resetToDefaultFocusing() {
		enhanceDefaultFocusing(getModel());
	}
}