@Override
	public IFigure createFigure() {
		ResizableCompartmentFigure rcf = (ResizableCompartmentFigure) super.createFigure();
		  rcf.getContentPane().setLayoutManager(newConstrainedToolbarL ayout(
				HORIZONTAL, 
				STRETCH_NOT, 
				STRETCH_NOT, 
				DEFAULT_SPACING, 
				ALIGN_TOPLEFT));
		rcf.setBorder(null); // remove unwanted horizontal rule above compartment 
		return rcf;
	}

	protected ConstrainedToolbarLayout newConstrainedToolbarLayout(boolean vertical, 
			boolean stretchMajorAxis, boolean stretchMinorAxis, 
			int spacing,
			int minorAlignment) {
		ConstrainedToolbarLayout layout = new ConstrainedToolbarLayout(vertical);
		layout.setStretchMajorAxis(stretchMajorAxis);
		layout.setStretchMinorAxis(stretchMinorAxis);
		layout.setSpacing(spacing);
		layout.setMinorAlignment(minorAlignment);
		layout.setIgnoreInvisibleChildren(true);
		
		return layout;
	}

/**
 * Layout edit policy that allows moving elements by drag and drop.
 *
 * @author sas
 */
public class CompartmentEditPolicy extends ConstrainedToolbarLayoutEditPolicy {
	
	/**
	 * the containing feature this edit policy works on
	 */
	private final EStructuralFeature mContainingFeature;

	/**
	 * Constructs a {@link CompartmentEditPolicy} that works on the given containing feature.
	 * 
	 * @param isHorizontal denotes whether the given compartment uses a horizontal layout 
	 * @param containingFeature the containing feature we work on
	 */
	public CompartmentEditPolicy(EStructuralFeature containingFeature) {
		super();
		
		Assert.isNotNull(containingFeature, "containing feature must be set");
		
		this.mContainingFeature = containingFeature;
	}
	
	protected EditPolicy createChildEditPolicy(EditPart child) {
		ResizableEditPolicyEx policy = new ResizableEditPolicyEx();
		policy.setResizeDirections(0);
		return policy;
	}

	@Override
	protected Command getMoveChildrenCommand(Request request) {
		
		CompoundCommand command = new CompoundCommand();
		List<?> editParts = ((ChangeBoundsRequest)request).getEditParts();
		
		EditPart insertionReference = getInsertionReference(request);
		for (int i = 0; i < editParts.size(); i++) {
			EditPart child = (EditPart)editParts.get(i);
			command.add(createMoveChildCommand(child, insertionReference));
		}
		return command.unwrap();
	}
	
	protected Command createMoveChildCommand(EditPart child, EditPart after) {	
		int newIndex;
		int displacement;

		int childIndex = getHost().getChildren().indexOf(child);
		int afterIndex = getHost().getChildren().indexOf(after);	

		if(afterIndex == -1) {
			newIndex = getHost().getChildren().size()-1;			
			displacement = newIndex - childIndex;
		} else {		
			newIndex = afterIndex;
			displacement = afterIndex - childIndex;
			if (childIndex <= afterIndex) {
				newIndex--;
				displacement--;			
			}
		}


		TransactionalEditingDomain editingDomain = ((IGraphicalEditPart) getHost()).getEditingDomain();
		CompartmentChildRepositionCommand command = new CompartmentChildRepositionCommand(editingDomain, 
				child.getParent(), ((View) child.getParent().getModel()).getElement(), 
				mContainingFeature, childIndex, newIndex);

		eraseLayoutTargetFeedback(null);
		return new ICommandProxy(command);
	}
	
	protected EditPart getInsertionReference(Request request) {
		List<?> children = getHost().getChildren();

		if (request.getType().equals(RequestConstants.REQ_CREATE)) {
			int i = getFeedbackIndexFor(request);
			if (i == -1)
				return null;
			return (EditPart)children.get(i);
		}

		int index = getFeedbackIndexFor(request);
		if (index != -1) {
			List<?> selection = getHost().getViewer().getSelectedEditParts();
			do {
				EditPart editpart = (EditPart) children.get(index);
				if (!selection.contains(editpart))
					return editpart;
			} while (++index  < children.size());
		}
		return null; //Not found, add at the end.
	}

	/**
	 * @param request the Request
	 * @return the index for the insertion reference
	 */
	protected int getFeedbackIndexFor(Request request) {
		List<?> children = getHost().getChildren();
		if (children.isEmpty())
			return -1;
			
		Transposer transposer = new Transposer();
		transposer.setEnabled (!isHorizontal());
		
		Point p = transposer.t(getLocationFromRequest(request));

		// Current row bottom, initialize to above the top.
		int rowBottom = Integer.MIN_VALUE;
		int candidate = -1;
		for (int i = 0; i < children.size(); i++) {
			EditPart child = (EditPart) children.get(i);
			Rectangle rect = transposer.t(getAbsoluteBounds(((GraphicalEditPart)child)));
			if (rect.y > rowBottom) {
				/*
				 * We are in a new row, so if we don't have a candidate but yet are within the
				 * previous row, then the current entry becomes the candidate. This is because
				 * we know we must be to the right of center of the last Figure in the
				 * previous row, so this Figure (which is at the start of a new row) is the
				 * candidate.
				 */
				if (p.y <= rowBottom) {
					if (candidate == -1)
						candidate = i;
					break;
				} else
					candidate = -1; // Mouse's Y is outside the row, so reset the candidate
			}
			rowBottom = Math.max(rowBottom, rect.bottom());
			if (candidate == -1) {
				/*
				 * See if we have a possible candidate. It is a candidate if the cursor is
				 * left of the center of this candidate.
				 */
				if (p.x <= rect.x + (rect.width / 2))
					candidate = i;
			}
			if (candidate != -1) {
				// We have a candidate, see if the rowBottom has grown to include the mouse Y.
				if (p.y <= rowBottom) {
					/*
					 * Now we have determined that the cursor.Y is above the bottom of the
					 * current row of figures. Stop now, to prevent the next row from being
					 * searched
					 */
					break;
				}
			}
		}
		return candidate;
	}
	
	private Point getLocationFromRequest(Request request) {
		return ((DropRequest)request).getLocation();
	}

	private Rectangle getAbsoluteBounds(GraphicalEditPart ep) {
		Rectangle bounds = ep.getFigure().getBounds().getCopy();
		ep.getFigure().translateToAbsolute(bounds);
		return bounds;
	}



}

/**
 * This command repositions an element inside an compartment. 
 * 
 * @author sas
 */
public class CompartmentChildRepositionCommand extends AbstractTransactionalCommand {

	/**
	 * the visual representation of the model container we work on
	 */
	private final EditPart mContainerPart;
	
	/**
	 * the container we work on
	 */
	private final EObject mContainer;
	
	/**
	 * the containing feature
	 */
	private final EStructuralFeature mContainingFeature;
	
	/**
	 * the old index
	 */
	private final int mOldIndex;
	
	/**
	 * the new index
	 */
	private final int mNewIndex;


	
	/**
 	 * Constructs a runtime instance of <code>CompartmentRepositionElementCommand</code>.
	 */
	public CompartmentChildRepositionCommand(TransactionalEditingDomain editingDomain,
			EditPart containerPart, EObject container, EStructuralFeature containingFeature,
			int oldIndex, int newIndex) {
		super(editingDomain, "", getWorkspaceFiles(container));
		
		Assert.isNotNull(containerPart);
		this.mContainerPart = containerPart;
		Assert.isNotNull(container);
		this.mContainer = container;
		Assert.isNotNull(containingFeature);
		this.mContainingFeature = containingFeature;
		Assert.isTrue(oldIndex >= 0);
		this.mOldIndex = oldIndex;
		Assert.isTrue(newIndex >= -1);
		this.mNewIndex = newIndex;
	}
	
	/**
	 * Convenience method to access <code>mContainer.eGet(mContainingFeature)</code>.
	 * 
	 * @return the containing {@link EList} or <code>null</code> if the containing feature doesn't 
	 * reference an {@link EList}
	 */
	protected EList<?> getContainingList() {
		Object featureValue = mContainer.eGet(mContainingFeature);
		return featureValue instanceof EList<?> ? (EList<?>) featureValue : null;
	}
	

	@Override
	public boolean canExecute() {
		// containing feature needs to be set
		if (!mContainer.eIsSet(mContainingFeature)) {
			return false;
		}
		
		// containing feature needs to reference an EList
		if (getContainingList() == null) {
			return false;
		}
		
		// ensure valid value of mOldIndex
		if (mOldIndex < 0 || mOldIndex >= getContainingList().size()) {
			return false;
		}
		
		return true;
	}

	@Override
	protected CommandResult doExecuteWithResult(IProgressMonitor monitor,
			IAdaptable info) throws ExecutionException {
		CommandResult commandResult = null;
		try {
			// reposition model element
    		getContainingList().move(mNewIndex, mOldIndex);
			
    		// reposition visual representation of model element
    		View containerView = (View) mContainerPart.getModel();
    		View childView = (View) containerView.getChildren().get(mOldIndex);
			ViewUtil.repositionChildAt(containerView, childView, mNewIndex);

			// refresh container part
			mContainerPart.refresh();		
        } catch (RuntimeException exp){
            commandResult = CommandResult.newErrorCommandResult(exp);
        }
		return (commandResult == null) ? CommandResult.newOKCommandResult()
			: commandResult;

	}

}

public class CompartmentChildCreationEditPolicy extends CreationEditPolicy {

	@Override
	protected Command getCreateCommand(CreateViewRequest request) {
		TransactionalEditingDomain editingDomain = ((IGraphicalEditPart) getHost())
		.getEditingDomain();
		CompositeTransactionalCommand cc = new CompositeTransactionalCommand(
				editingDomain, DiagramUIMessages.AddCommand_Label);

		Iterator<?> descriptors = request.getViewDescriptors().iterator();

		while (descriptors.hasNext()) {
			CreateViewRequest.ViewDescriptor descriptor =
				(CreateViewRequest.ViewDescriptor)descriptors.next();

			CreateCommand createCommand =
				new CompartmentChildCreateCommand(editingDomain,
						descriptor, 
						(View)(getHost().getModel()), getFeedbackIndexFor(request));

			cc.compose(createCommand);
		}
		return new ICommandProxy(cc.reduce());
	}


	protected int getFeedbackIndexFor(Request request) {
		List<?> children = getHost().getChildren();
		if (children.isEmpty())
			return -1;

		Transposer transposer = new Transposer();
		transposer.setEnabled (!isHorizontal());

		Point p = transposer.t(getLocationFromRequest(request));

		// Current row bottom, initialize to above the top.
		int rowBottom = Integer.MIN_VALUE;
		int candidate = -1;
		for (int i = 0; i < children.size(); i++) {
			EditPart child = (EditPart) children.get(i);
			Rectangle rect = transposer.t(getAbsoluteBounds(((GraphicalEditPart)child)));
			if (rect.y > rowBottom) {
				/*
				 * We are in a new row, so if we don't have a candidate but yet are within the
				 * previous row, then the current entry becomes the candidate. This is because
				 * we know we must be to the right of center of the last Figure in the
				 * previous row, so this Figure (which is at the start of a new row) is the
				 * candidate.
				 */
				if (p.y <= rowBottom) {
					if (candidate == -1)
						candidate = i;
					break;
				} else
					candidate = -1; // Mouse's Y is outside the row, so reset the candidate
			}
			rowBottom = Math.max(rowBottom, rect.bottom());
			if (candidate == -1) {
				/*
				 * See if we have a possible candidate. It is a candidate if the cursor is
				 * left of the center of this candidate.
				 */
				if (p.x <= rect.x + (rect.width / 2))
					candidate = i;
			}
			if (candidate != -1) {
				// We have a candidate, see if the rowBottom has grown to include the mouse Y.
				if (p.y <= rowBottom) {
					/*
					 * Now we have determined that the cursor.Y is above the bottom of the
					 * current row of figures. Stop now, to prevent the next row from being
					 * searched
					 */
					break;
				}
			}
		}
		return candidate;
	}

	protected boolean isHorizontal() {
		IFigure figure = ((GraphicalEditPart)getHost()).getContentPane();
		return ((ConstrainedToolbarLayout)figure.getLayoutManager()).isHorizontal();
	}

	private Point getLocationFromRequest(Request request) {
		return ((DropRequest)request).getLocation();
	}

	private Rectangle getAbsoluteBounds(GraphicalEditPart ep) {
		Rectangle bounds = ep.getFigure().getBounds().getCopy();
		ep.getFigure().translateToAbsolute(bounds);
		return bounds;
	}
}

public class CompartmentChildCreateCommand extends CreateCommand {

	int index;

	public CompartmentChildCreateCommand (TransactionalEditingDomain editingDomain, ViewDescriptor viewDescriptor,
			View containerView, int index) {
		super(editingDomain, viewDescriptor, containerView);
		this.index = index;
	}

	@Override
	protected CommandResult doExecuteWithResult(IProgressMonitor monitor, IAdaptable info)
	throws ExecutionException {
		View view =
			ViewService.getInstance().createView(
					viewDescriptor.getViewKind(),
					viewDescriptor.getElementAdapter(),
					containerView,
					viewDescriptor.getSemanticHint(),
					index,
					viewDescriptor.isPersisted(),
					viewDescriptor.getPreferencesHint());
		if (view == null) {
			return super.doExecuteWithResult(monitor, info);
		}
		
		Assert.isNotNull(view, "failed to create a view");
		viewDescriptor.setView(view);
		

		return CommandResult.newOKCommandResult(viewDescriptor);
	}

}