path: root/extraplugins/qompass/codegen/cpp/org.eclipse.papyrus.views.cpp/src/org/eclipse/papyrus/views/panels/CppOperationPanel.java

/*******************************************************************************
 * Copyright (c) 2006 - 2007 CEA LIST.
 * 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:
 *     CEA LIST - initial API and implementation
 *******************************************************************************/

package org.eclipse.papyrus.views.panels;

import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.papyrus.C_Cpp.Const;
import org.eclipse.papyrus.C_Cpp.ConstInit;
import org.eclipse.papyrus.C_Cpp.Friend;
import org.eclipse.papyrus.C_Cpp.Inline;
import org.eclipse.papyrus.C_Cpp.Virtual;
import org.eclipse.papyrus.uml.tools.utils.StereotypeUtil;
import org.eclipse.papyrus.views.cpp.CommandSupport;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.FormAttachment;
import org.eclipse.swt.layout.FormData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;
import org.eclipse.uml2.uml.Behavior;
import org.eclipse.uml2.uml.Class;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.OpaqueBehavior;
import org.eclipse.uml2.uml.Operation;
import org.eclipse.uml2.uml.UMLPackage;
import org.eclipse.uml2.uml.profile.standard.Create;
import org.eclipse.uml2.uml.profile.standard.Destroy;
import org.eclipse.uml2.uml.util.UMLUtil;


/**
 * Panel displayed when an Operation is selected
 *
 * TODO: instead of keeping isAbstract and pureVirtual Stereotype synchronized, pure virtual
 * could be removed from the panel
 * @deprecated This view will be replaced by a XWT view for the C++ profile
 */
@Deprecated
public class CppOperationPanel extends CppAbstractPanel {

	@SuppressWarnings("unused")
	private ISourceViewer viewerBody;

	@SuppressWarnings("unused")
	private ISourceViewer viewerConstInit;

	private Group groupBody;

	private Group groupCInit;

	// document used by the viewer
	private IDocument docBody;

	private IDocument docConstInit;

	private Button isStatic;

	private Button isInline;

	private Button isConst;

	private Button isFriend;

	private Button isCreate;

	private Button isDestroy;

	private Combo vPropCombo;

	private Operation selectedOperation;

	Element selectedEOwner;

	protected String origBody;
	
	public CppOperationPanel(Composite parent, int style) {
		super(parent, style);
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see com.cea.accordcpp.core.ui.panels.AccordCppAbstractPanel#getSelectedElement()
	 */
	@Override
	public Operation getSelectedElement() {
		return selectedOperation;
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see com.cea.accordcpp.core.ui.panels.AccordCppAbstractPanel#setSelectedElement(java.lang.Element)
	 */
	@Override
	public void setSelectedElement(Element newElement) {
		super.setSelectedElement(newElement);
		if (newElement instanceof Operation) {
			this.selectedOperation = (Operation) newElement;
			// Retrieve the owner
			this.selectedEOwner = selectedOperation.getOwner();
		}
		else {
			throw new RuntimeException("bad selection: " + newElement + " should be an uml2 Operation");
		}
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see com.cea.accorduml.ui.views.panels.AccordUMLAbstractPanel#createContent()
	 */
	@Override
	public Control createContent()
	{
		// /////////////////////////////////////////////////////////////////////
		// Create checkboxes
		// /////////////////////////////////////////////////////////////////////
		isStatic = createButton("isStatic", this, null);
		isInline = createButton("isInline", this, isStatic);
		isConst = createButton("isConst", this, isInline);
		isFriend = createButton("isFriend", this, isConst);
		isCreate = createButton("isCreate", this, isFriend);
		isDestroy = createButton("isDestroy", this, isCreate);

		// /////////////////////////////////////////////////////////////////////
		// Add checkboxes listeners
		// /////////////////////////////////////////////////////////////////////
		isStatic.addSelectionListener(new SelectionListener() {

			@Override
			public void widgetSelected(SelectionEvent e) {
				CommandSupport.exec("C++ operation save", new Runnable() {

					@Override
					public void run() {
						updateModel();
					}
				});
			}

			@Override
			public void widgetDefaultSelected(SelectionEvent e) {
			}
		});

		addStereotypeSelectionListener(isInline, "Inline");
		addStereotypeSelectionListener(isConst, "Const");
		addStereotypeSelectionListener(isFriend, "Friend");
		addStereotypeSelectionListener(isCreate, "Create");
		addStereotypeSelectionListener(isDestroy, "Destroy");

		// /////////////////////////////////////////////////////////////////////
		// Virtual properties combo box
		// /////////////////////////////////////////////////////////////////////
		vPropCombo = new Combo(this, SWT.DROP_DOWN | SWT.READ_ONLY);
		String items[] = { "not virtual", "virtual", "pure virtual" };
		vPropCombo.setItems(items);
		vPropCombo.setText("Virtual operation qualifiers");
		vPropCombo.addSelectionListener(
				new SelectionAdapter() {

					@Override
					public void widgetSelected(SelectionEvent event) {
						checkVirtual();
						reset();
					}
				});

		FormData data = new FormData();
		data.left = new FormAttachment(isDestroy, H_SPACE);
		data.top = new FormAttachment(0, H_SPACE);
		vPropCombo.setLayoutData(data);

		// /////////////////////////////////////////////////////////////////////
		// Create save reset buttons with superclass method
		// /////////////////////////////////////////////////////////////////////
		createSaveResetButtons();

		// /////////////////////////////////////////////////////////////////////
		// Constructor init list
		// /////////////////////////////////////////////////////////////////////
		docConstInit = createDocument();
		groupCInit = createGroup(
				this
				, "Constructor initialisation list"
				, isStatic
				, null
				, true
				, 0
				, 0
				, false);

		// Use CDT CEditor coloration
		viewerConstInit = createViewer(docConstInit, groupCInit);

		// /////////////////////////////////////////////////////////////////////
		// Body
		// /////////////////////////////////////////////////////////////////////

		docBody = createDocumentC();
		groupBody = createGroup(
				this
				, "Method body"
				, groupCInit
				, null
				, true
				, 0
				, 0
				, true);
		// Use CDT CEditor coloration
		viewerBody = createViewerC(docBody, groupBody);

		// /////////////////////////////////////////////////////////////////////

		return this;
	}



	/*
	 * (non-Javadoc)
	 *
	 * @see com.cea.accordcpp.core.ui.panels.AccordCppAbstractPanel#save()
	 */
	@Override
	public void save()
	{
		if (selectedOperation == null) {
			/* Log.debug("saveBody : selectedOperation is null"); */
		} else {
			CommandSupport.exec("C++ operation save", new Runnable() {

				@Override
				public void run() {
					String newConstInit = docConstInit.get();
					if (newConstInit.equals("")) { //$NON-NLS-1$
						StereotypeUtil.unapply(selectedOperation, ConstInit.class);
					} else {
						ConstInit cppConstInit =
								StereotypeUtil.applyApp(selectedOperation, ConstInit.class);
						cppConstInit.setInitialisation(newConstInit);
					}

					// Body
					setCppBody(selectedOperation, docBody.get());
					origBody = docBody.get();
				}
			});
		}

	}

	public static String getCppBody(Operation operation)
	{
		// get the body of the operation
		for (Behavior behavior : operation.getMethods()) {
			if (behavior instanceof OpaqueBehavior) {
				OpaqueBehavior ob = (OpaqueBehavior) behavior;
				int i = 0;
				for (String language : ob.getLanguages()) {
					if (language.equals(C_CPP_ID)) {
						return ob.getBodies().get(i);
					}
					else if (language.equals(CPP_ID)) {
						return ob.getBodies().get(i);
					}
					else if (language.equals(C_ID)) {
						return ob.getBodies().get(i);
					}
					i++;
				}
			}
		}
		return ""; //$NON-NLS-1$
	}

	public static void setCppBody(Operation operation, String body)
	{
		boolean done = false;
		for (Behavior behavior : operation.getMethods()) {
			if (behavior instanceof OpaqueBehavior) {
				OpaqueBehavior ob = (OpaqueBehavior) behavior;
				int i = 0;
				for (String language : ob.getLanguages()) {
					if (language.equals(C_CPP_ID) || language.equals(CPP_ID) || language.equals(C_ID)) {
						done = true;
						ob.getBodies().set(i, body);
						break;
					}
					i++;
				}
			}
			if (done) {
				break;
			}
		}
		if (!done) {
			OpaqueBehavior ob = (OpaqueBehavior)
					operation.getClass_().createOwnedBehavior(operation.getName(), UMLPackage.eINSTANCE.getOpaqueBehavior());
			ob.getLanguages().add(C_CPP_ID);
			ob.getBodies().add(body);
			ob.setSpecification(operation);
		}

	}

	/**
	 * Called when the static checkbox is modified
	 */
	protected void checkStatic()
	{
		boolean boxState = isStatic.getSelection();

		selectedOperation.setIsStatic(boxState);
	}

	/**
	 * Called when the inline checkbox is modified
	 */
	protected void checkInline() {
		// get the text in the activity
		boolean boxState = isInline.getSelection();

		if (boxState != StereotypeUtil.isApplied(selectedOperation, Inline.class)) {
			if (boxState) {
				StereotypeUtil.apply(selectedOperation, Inline.class);
			}
			else {
				StereotypeUtil.unapply(selectedOperation, Inline.class);
			}
		}
	}

	/**
	 * Called when the const checkbox is modified
	 */
	protected void checkConst() {

		boolean boxState = isConst.getSelection();

		if (boxState != StereotypeUtil.isApplied(selectedOperation, Const.class)) {
			if (boxState) {
				StereotypeUtil.apply(selectedOperation, Const.class);
			}
			else {
				StereotypeUtil.unapply(selectedOperation, Const.class);
			}
		}
	}

	/**
	 * Called when the friend checkbox is modified
	 */
	protected void checkFriend() {

		boolean boxState = isFriend.getSelection();

		if (boxState != StereotypeUtil.isApplied(selectedOperation, Friend.class)) {
			if (boxState) {
				StereotypeUtil.apply(selectedOperation, Friend.class);
			}
			else {
				StereotypeUtil.unapply(selectedOperation, Friend.class);
			}
		}
	}

	/**
	 * Called when the create checkbox is modified
	 */
	protected void checkCreate() {
		// get the text in the activity
		boolean boxState = isCreate.getSelection();

		if (boxState) {
			StereotypeUtil.apply(selectedOperation, Create.class);
		}
		else {
			StereotypeUtil.unapply(selectedOperation, ConstInit.class);
			StereotypeUtil.unapply(selectedOperation, Create.class);
		}

		groupCInit.setEnabled(boxState);
	}

	/**
	 * Called when the destroy checkbox is modified
	 */
	protected void checkDestroy() {
		// get the text in the activity
		boolean boxState = isDestroy.getSelection();

		if (boxState) {
			StereotypeUtil.apply(selectedOperation, Destroy.class);
		}
		else {
			StereotypeUtil.unapply(selectedOperation, Destroy.class);
		}
	}

	/**
	 * Called when the virtual qualifier is modified
	 */
	protected void checkVirtual() {

		// Treat the operation
		int comboSelected = 2;

		// If owner is a class
		if (selectedEOwner instanceof org.eclipse.uml2.uml.Class) {
			comboSelected = vPropCombo.getSelectionIndex();
		} else {
			// Assume this is an interface
			comboSelected = 2;
		}

		if (comboSelected == 0 /* not virtual */) {

			selectedOperation.setIsAbstract(false);
			StereotypeUtil.unapply(selectedOperation, Virtual.class);
		}
		else if (comboSelected == 1 /* virtual */) {

			selectedOperation.setIsAbstract(false);
			StereotypeUtil.apply(selectedOperation, Virtual.class);
		}
		else if (comboSelected == 2 /* pure virtual */) {

			selectedOperation.setIsAbstract(true);
			StereotypeUtil.apply(selectedOperation, Virtual.class);
		}

		// Treat the owner class
		if (selectedEOwner instanceof Class) {
			Class ownerCl = (Class) selectedEOwner;

			ownerCl.setIsAbstract(ownerCl.isAbstract());
		} // else nothing
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see com.cea.accorduml.ui.views.panels.AccordUMLAbstractPanel#entryAction()
	 */
	@Override
	public void entryAction() {
		super.entryAction();
		reset();
	}

	/*
	 * (non-Javadoc)
	 *
	 * @see com.cea.accorduml.ui.views.panels.AccordUMLAbstractPanel#exitAction()
	 */
	@Override
	public void exitAction() {
		// do exit action, only if the owner is a class
		if (selectedEOwner instanceof Class) {
			super.exitAction();
		}
	}

	@Override
	public boolean checkModifications() {
		// check if ConstInit has changed
		String valueConstInit = ""; //$NON-NLS-1$
		ConstInit constInit = UMLUtil.getStereotypeApplication(selectedOperation, ConstInit.class);
		if (constInit != null) {
			valueConstInit = constInit.getInitialisation();
		}
		if (!docConstInit.get().equals(valueConstInit)) {
			return true;
		}

		// String methodBody = getCppBody(selectedOperation);
		if (!(docBody.get().equals(origBody))) {
			return true;
		}

		return false;
	}

	@Override
	protected void refreshPanel() {
		if (selectedOperation == null) {
			/* Log.debug("resetBody : selectedOperation is null"); */
		} else {

			// get the text in the activity if parent is a class
			if (selectedEOwner instanceof Class) {

				// This part is done for a class only
				ConstInit constInit = UMLUtil.getStereotypeApplication(selectedOperation, ConstInit.class);
				if (constInit != null) {
					docConstInit.set(constInit.getInitialisation());
				}

				// Don't show this unless the operation is a constructor
				if (isCreate.getSelection()) {
					groupCInit.setEnabled(true);
				} else {
					docConstInit.set(""); //$NON-NLS-1$
					groupCInit.setEnabled(false);
				}

				String body = getCppBody(selectedOperation);
				origBody = body;
				docBody.set(body);

				// Combo Box
				if (selectedOperation.isAbstract()) {
					vPropCombo.select(2);
					// Nothing in body and body unavailable
					docBody.set(""); //$NON-NLS-1$
					groupBody.setEnabled(false);
				}
				else {
					if (StereotypeUtil.isApplied(selectedOperation, Virtual.class)) {
						vPropCombo.select(1);
						groupBody.setEnabled(true);
					}
					else {
						vPropCombo.select(0);
						groupBody.setEnabled(true);
					}
				}

				// Inline
				if (StereotypeUtil.isApplied(selectedOperation, Inline.class)) {
					isInline.setSelection(true);
				}

			}
			else {
				// Don't show text areas nor buttons
				groupBody.setVisible(false);
				buttonSave.setVisible(false);
				buttonCancel.setVisible(false);

				// Methods are virtual pure
				vPropCombo.select(2);
				vPropCombo.setEnabled(false);

				// Inline not visible
				isInline.setVisible(false);
			}

			isStatic.setSelection(selectedOperation.isStatic());
			isConst.setSelection(StereotypeUtil.isApplied(selectedOperation, Const.class));
			isFriend.setSelection(StereotypeUtil.isApplied(selectedOperation, Friend.class));
			isCreate.setSelection(StereotypeUtil.isApplied(selectedOperation, Create.class));
			isDestroy.setSelection(StereotypeUtil.isApplied(selectedOperation, Destroy.class));
		}
	}

	@Override
	protected boolean isModelValid() {
		if (selectedOperation == null) {
			return true;
		}
		if (selectedEOwner instanceof Class) {

			if (selectedOperation.isAbstract()) {
				if (!StereotypeUtil.isApplied(selectedOperation, Virtual.class)) {
					return false;
				}
			}
		} else {
			// owner is interface
			if (!selectedOperation.isAbstract()) {
				return false;
			}
			if (StereotypeUtil.isApplied(selectedOperation, Virtual.class)) {
				return false;
			}
		}
		return true;

	}

	@Override
	protected void updateModel()
	{
		CommandSupport.exec("C++ operation save", new Runnable() {

			@Override
			public void run()
			{
				// Check button changes
				checkStatic();
				checkConst();
				checkCreate();
				checkDestroy();
				checkInline();
				checkFriend();

				if (selectedOperation == null) {
					return;
				}
				if (selectedEOwner instanceof Class) {
					// toggle Stereotypes pure virtual if element is abstract
					if (selectedOperation.isAbstract()) {
						if (!StereotypeUtil.isApplied(selectedOperation, Virtual.class)) {
							// selectedOperation.toggleStereotype("VirtualPure", true);
							// selectedOperation.toggleStereotype("Virtual", false);
						} else {
							// selectedOperation.toggleStereotype("Virtual", false);
						}
					}

					// if element is abstract and has VirtualPure, set to Virtual only
					if (!selectedOperation.isAbstract()) {
						if (StereotypeUtil.isApplied(selectedOperation, Virtual.class)) {
							// selectedOperation.toggleStereotype("VirtualPure", false);
							// selectedOperation.toggleStereotype("Virtual", true);
						} else {
							// selectedOperation.toggleStereotype("VirtualPure", false);
							// selectedOperation.toggleStereotype("Virtual", false);
						}
					}
				}
				else {
					selectedOperation.setIsAbstract(true);
					// selectedOperation.toggleStereotype("Virtual", false);
					// selectedOperation.toggleStereotype("VirtualPure", true);
				}
			}
		});
	}
}