| /**
|
| * Copyright (c) 2012, 2019 Mia-Software.
|
| *
|
| * All rights reserved. This program and the accompanying materials
|
| * are made available under the terms of the Eclipse Public License v2.0
|
| * which accompanies this distribution, and is available at
|
| * http://www.eclipse.org/legal/epl-v20.html
|
| *
|
| * Contributors:
|
| * Alban Ménager (Soft-Maint) - Bug 387470 - [EFacet][Custom] Editors
|
| */ |
| package org.eclipse.modisco.facet.util.ui.internal.exported.util.tree.menu;
|
|
|
| import java.util.LinkedList;
|
| import java.util.List;
|
| import java.util.Map;
|
|
|
| import org.eclipse.modisco.facet.util.ui.internal.exported.tree.menu.ITreeMenu;
|
| import org.eclipse.modisco.facet.util.ui.internal.exported.util.tree.ExtendedTree;
|
| import org.eclipse.modisco.facet.util.ui.internal.exported.util.tree.item.AbstractTreeItem;
|
| import org.eclipse.swt.events.MenuEvent;
|
| import org.eclipse.swt.events.MenuListener;
|
| import org.eclipse.swt.widgets.Control;
|
| import org.eclipse.swt.widgets.Menu;
|
| import org.eclipse.swt.widgets.Tree;
|
| import org.eclipse.swt.widgets.TreeItem;
|
|
|
| /**
|
| * This class provide the creation of the menu {@link Menu} of the tree (
|
| * {@link #createMenu(Control, ExtendedTree)}. The menu add a list of
|
| * {@link AbstractTreeItem} and for each an {@link AbstractTreeItem} which will
|
| * be instantiate when the menu item is selected.
|
| *
|
| * @since 0.3
|
| */
|
| public class ExtendedTreeMenu<IDialog> implements ITreeMenu<IDialog> {
|
|
|
| private final Control parent;
|
| private final ExtendedTree treeExtended;
|
| private final List<AbstractTreeMenu<IDialog>> menuItems;
|
| private Menu menu;
|
|
|
| /**
|
| * Constructor.
|
| *
|
| * @param parent
|
| * the parent of the menu.
|
| * @param treeExtended
|
| * the tree to which the menu will be linked.
|
| * @param menuItems
|
| */
|
| public ExtendedTreeMenu(final Control parent, final ExtendedTree treeExtended,
|
| final List<AbstractTreeMenu<IDialog>> menuItems) {
|
| this.parent = parent;
|
| this.treeExtended = treeExtended;
|
| this.menuItems = menuItems;
|
| }
|
|
|
| /**
|
| * This method creates the tree menu, add put the listener into the menu.
|
| *
|
| * @param parent
|
| * the parent of the menu.
|
| * @param treeExtended
|
| * the associated {@link ExtendedTree} of the menu.
|
| */
|
| public void createMenu() {
|
| this.menu = new Menu(this.parent);
|
| this.menu.addMenuListener(new MenuListener() {
|
|
|
| public void menuShown(final MenuEvent menuEvent) {
|
| onMenuShown();
|
| }
|
|
|
| public void menuHidden(final MenuEvent menuEvent) {
|
| // Nothing.
|
| }
|
| });
|
| }
|
|
|
| /**
|
| * This method is called when the menu is displayed. It calls all the
|
| * {@link AbstractTreeMenu#refresh(TreeMenu)} method of each element of the
|
| * menu.
|
| */
|
| public void onMenuShown() {
|
| for (final AbstractTreeMenu<IDialog> menuItem : this.getMenuItems()) {
|
| menuItem.refresh(this);
|
| }
|
| }
|
|
|
| /**
|
| * Return the list of all the items of this menu.
|
| *
|
| * @return the list of the {@link AbstractTreeMenu} of this menu.
|
| */
|
| public List<AbstractTreeMenu<IDialog>> getTreeMenuItems() {
|
| return this.getMenuItems();
|
| }
|
|
|
| /**
|
| * Return the {@link Menu} of this TreeMenu.
|
| *
|
| * @return the menu.
|
| */
|
| public Menu getMenu() {
|
| return this.menu;
|
| }
|
|
|
| /**
|
| * Put this <code>properties</code> to each items created.
|
| *
|
| * @param properties
|
| * the list of properties to pass.
|
| */
|
| public void putExtraProperties(final Map<String, Object> properties) {
|
| for (final AbstractTreeMenu<IDialog> menuItem : this.getMenuItems()) {
|
| menuItem.setExtraProperties(properties);
|
| }
|
| }
|
|
|
| /**
|
| * @return the current {@link TreeItem} selected on the tree.
|
| */
|
| public TreeItem getCurrentItemSelected() {
|
| TreeItem result = null;
|
| final TreeItem[] items = this.treeExtended.getTree().getSelection();
|
| if (items.length > 0) {
|
| result = this.treeExtended.getTree().getSelection()[0];
|
| }
|
| return result;
|
| }
|
|
|
| /**
|
| * @return the {@link AbstractTreeItem} selected on the tree. Can be null.
|
| */
|
| public AbstractTreeItem<IDialog> getTreeItemExtended(final TreeItem treeItem) {
|
| AbstractTreeItem<IDialog> result = null;
|
| for (final AbstractTreeMenu<IDialog> menuItem : this.getMenuItems()) {
|
| final AbstractTreeItem<IDialog> itemExtended = menuItem
|
| .getTreeItemExtended(treeItem);
|
| if (itemExtended != null) {
|
| result = itemExtended;
|
| break;
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| /**
|
| * @return the {@link AbstractTreeMenu} selected on the tree. Can be null.
|
| */
|
| public AbstractTreeMenu<IDialog> getTreeMenu(final TreeItem treeItem) {
|
| AbstractTreeMenu<IDialog> result = null;
|
|
|
| for (final AbstractTreeMenu<IDialog> menuItem : this.getMenuItems()) {
|
| final AbstractTreeItem<IDialog> itemExtended = menuItem
|
| .getTreeItemExtended(treeItem);
|
| if (itemExtended != null) {
|
| result = menuItem;
|
| break;
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| /**
|
| * Remove the current item selected of the tree.
|
| */
|
| public void removeCurrentItemSelected() {
|
| final AbstractTreeMenu<IDialog> treeMenu = getTreeMenu(getCurrentItemSelected());
|
| if (treeMenu != null) {
|
| treeMenu.removeItem(getCurrentItemSelected());
|
| }
|
| }
|
|
|
| /**
|
| * @return the {@link Tree}.
|
| */
|
| public Tree getTree() {
|
| return this.treeExtended.getTree();
|
| }
|
|
|
| /**
|
| * This method call the method
|
| * {@link AbstractTreeItem#onItemMouseSelection()} of the current selection.
|
| */
|
| public void onMouseSelection() {
|
| final AbstractTreeItem<IDialog> treeMenu = getTreeItemExtended(getCurrentItemSelected());
|
| if (treeMenu != null) {
|
| treeMenu.onItemMouseSelection();
|
| fireChanged();
|
| }
|
| }
|
|
|
| /**
|
| * When a modification append, this method has to be called and the method
|
| * {@link #notifyChanged()} is called for the listener of this Tree.
|
| */
|
| public void fireChanged() {
|
| this.treeExtended.fireChanged();
|
| }
|
|
|
| /**
|
| * @return the all the items of the menu.
|
| */
|
| private List<AbstractTreeMenu<IDialog>> getMenuItems() {
|
| return this.menuItems;
|
| }
|
|
|
| /**
|
| * Select the item into the menu (if the item exist).
|
| *
|
| * @return can return a {@link IDialog}. Can be null.
|
| */
|
| public IDialog selectMenuItem(
|
| final Class<? extends AbstractTreeMenuItem<IDialog>> menuItemType) {
|
| IDialog result = null;
|
| final AbstractTreeMenu<IDialog> treeMenu = findMenuItem(menuItemType);
|
| if (treeMenu != null) {
|
| result = treeMenu.onMenuItemSelection();
|
| }
|
| return result;
|
| }
|
|
|
| /**
|
| * Return (if exist) the {@link AbstractTreeMenu} with the name
|
| * <code>menuItemName</code> into the items of the tree menu.
|
| *
|
| * @param menuItemType
|
| * the name of the element to find.
|
| * @return the item menu with the name in parameter (can be null).
|
| */
|
| private AbstractTreeMenuItem<IDialog> findMenuItem(
|
| final Class<? extends AbstractTreeMenuItem<IDialog>> menuItemType) {
|
| AbstractTreeMenuItem<IDialog> result = null;
|
| for (final AbstractTreeMenuItem<IDialog> item : getAllTreeMenuItems()) {
|
| if (item.getClass().isInstance(menuItemType)) {
|
| result = item;
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| private List<AbstractTreeMenuItem<IDialog>> getAllTreeMenuItems() {
|
| final List<AbstractTreeMenuItem<IDialog>> result = new LinkedList<AbstractTreeMenuItem<IDialog>>();
|
| for (final AbstractTreeMenu<IDialog> menuItem : getMenuItems()) {
|
| if (menuItem instanceof AbstractTreeSubMenu) {
|
| result.addAll(getAllTreeMenuItems((AbstractTreeSubMenu<IDialog>) menuItem));
|
| } else {
|
| result.add((AbstractTreeMenuItem<IDialog>) menuItem);
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| private List<AbstractTreeMenuItem<IDialog>> getAllTreeMenuItems(
|
| final AbstractTreeSubMenu<IDialog> subMenu) {
|
| final List<AbstractTreeMenuItem<IDialog>> result = new LinkedList<AbstractTreeMenuItem<IDialog>>();
|
| for (final AbstractTreeMenu<IDialog> menuItem : subMenu.getItems()) {
|
| if (menuItem instanceof AbstractTreeSubMenu) {
|
| result.addAll(getAllTreeMenuItems((AbstractTreeSubMenu<IDialog>) menuItem));
|
| } else {
|
| result.add((AbstractTreeMenuItem<IDialog>) menuItem);
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| /**
|
| * @return the treeMenuItem into the menu with is an instance of the type in
|
| * parameter.
|
| */
|
| public AbstractTreeMenu<IDialog> getTreeMenuItem(final Class<?> treeMenuType) {
|
| AbstractTreeMenu<IDialog> result = null;
|
| final List<AbstractTreeMenu<IDialog>> treeMenuItems = getTreeMenuItems();
|
| for (final AbstractTreeMenu<IDialog> item : treeMenuItems) {
|
| result = getTreeMenuItem(item, treeMenuType);
|
| if (result != null) {
|
| break;
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| private AbstractTreeMenu<IDialog> getTreeMenuItem(
|
| final AbstractTreeSubMenu<IDialog> item,
|
| final Class<?> treeMenuType) {
|
| AbstractTreeMenu<IDialog> result = null;
|
| for (final AbstractTreeMenu<IDialog> subItem : item.getItems()) {
|
| result = getTreeMenuItem(subItem, treeMenuType);
|
| if (result != null) {
|
| break;
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| private AbstractTreeMenu<IDialog> getTreeMenuItem(
|
| final AbstractTreeMenu<IDialog> item,
|
| final Class<?> treeMenuType) {
|
| AbstractTreeMenu<IDialog> result = null;
|
| if (treeMenuType.isInstance(item)) {
|
| result = item;
|
| } else if (item instanceof AbstractTreeSubMenu) {
|
| result = getTreeMenuItem((AbstractTreeSubMenu<IDialog>) item,
|
| treeMenuType);
|
| }
|
| return result;
|
| }
|
|
|
| /**
|
| * get all the items of the tree with the name <code>treeItemName</code>
|
| *
|
| * @param treeItemName
|
| * the name of the item to select.
|
| * @return the list of all the tree item with the name in parameter.
|
| */
|
| public List<AbstractTreeItem<IDialog>> getTreeItems(
|
| final String treeItemName) {
|
| final List<AbstractTreeItem<IDialog>> result = new LinkedList<AbstractTreeItem<IDialog>>();
|
| for (final AbstractTreeMenuItem<IDialog> menuItem : getAllTreeMenuItems()) {
|
| for (final AbstractTreeItem<IDialog> treeItem : menuItem.getItems()) {
|
| if (treeItemName.equals(treeItem.getItemText())) {
|
| result.add(treeItem);
|
| }
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| /**
|
| * Select a item into the tree.
|
| *
|
| * @param treeItem
|
| * the {@link AbstractTreeItem} to select
|
| */
|
| public void selectTreeItem(final AbstractTreeItem<IDialog> treeItem) {
|
| this.treeExtended.getTree().setSelection(treeItem.getTreeItem());
|
| }
|
| }
|