| /******************************************************************************* |
| * Copyright (c) 2010 BSI Business Systems Integration AG. |
| * 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: |
| * BSI Business Systems Integration AG - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.scout.sdk.ui.wizard; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import org.eclipse.scout.sdk.ui.fields.bundletree.CheckableTree; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.DndEvent; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.ICheckStateListener; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.ITreeDndListener; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.ITreeNode; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.ITreeNodeFilter; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.NodeFilters; |
| import org.eclipse.scout.sdk.ui.fields.bundletree.TreeUtility; |
| import org.eclipse.scout.sdk.workspace.IScoutBundle; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Composite; |
| |
| /** |
| * <h3>BundleTreeWizardPage</h3> ... |
| * |
| * @author Andreas Hoegger |
| * @since 1.0.8 12.02.2010 |
| */ |
| public class BundleTreeWizardPage extends AbstractWorkspaceWizardPage { |
| |
| private CheckableTree m_tree; |
| private boolean m_treeListenersAttached; |
| |
| private final ITreeNode m_rootNode; |
| private final List<ITreeDndListener> m_tempDndListeners; |
| private final List<ICheckStateListener> m_tempCheckListeners; |
| private final ITreeNodeFilter m_initialCheckedFilter; |
| |
| public BundleTreeWizardPage(String pageTitle, String message, ITreeNode rootNode, ITreeNodeFilter initialCheckedFilter) { |
| super(BundleTreeWizardPage.class.getName()); |
| m_treeListenersAttached = false; |
| m_rootNode = rootNode; |
| m_tempDndListeners = new ArrayList<ITreeDndListener>(); |
| m_tempCheckListeners = new ArrayList<ICheckStateListener>(); |
| |
| setDescription(message); |
| setTitle(pageTitle); |
| if (initialCheckedFilter == null) { |
| initialCheckedFilter = NodeFilters.getAcceptNone(); |
| } |
| m_initialCheckedFilter = initialCheckedFilter; |
| } |
| |
| public synchronized void addCheckSelectionListener(ICheckStateListener listener) { |
| if (m_treeListenersAttached) { |
| m_tree.addCheckSelectionListener(listener); |
| } |
| else { |
| m_tempCheckListeners.add(listener); |
| } |
| } |
| |
| public synchronized void removeCheckSelectionListener(ICheckStateListener listener) { |
| if (m_treeListenersAttached) { |
| m_tree.removeCheckSelectionListener(listener); |
| } |
| else { |
| m_tempCheckListeners.remove(listener); |
| } |
| } |
| |
| public synchronized void addDndListener(ITreeDndListener listener) { |
| if (m_treeListenersAttached) { |
| m_tree.addDndListener(listener); |
| } |
| else { |
| m_tempDndListeners.add(listener); |
| } |
| } |
| |
| public synchronized void removeDndListener(ITreeDndListener listener) { |
| if (m_treeListenersAttached) { |
| m_tree.removeDndListener(listener); |
| } |
| else { |
| m_tempDndListeners.remove(listener); |
| } |
| } |
| |
| @Override |
| protected void createContent(Composite parent) { |
| m_tree = new CheckableTree(parent, getRootNode()); |
| m_tree.setChecked(TreeUtility.findNodes(getRootNode(), m_initialCheckedFilter)); |
| synchronized (this) { |
| for (ITreeDndListener l : m_tempDndListeners) { |
| m_tree.addDndListener(l); |
| } |
| m_tempDndListeners.clear(); |
| m_tree.addDndListener(new ITreeDndListener() { |
| @Override |
| public void validateTarget(DndEvent dndEvent) { |
| } |
| |
| @Override |
| public boolean isDragableNode(ITreeNode node) { |
| return true; |
| } |
| |
| @Override |
| public void dndPerformed(DndEvent dndEvent) { |
| pingStateChanging(); |
| } |
| }); |
| |
| for (ICheckStateListener l : m_tempCheckListeners) { |
| m_tree.addCheckSelectionListener(l); |
| } |
| m_tempCheckListeners.clear(); |
| m_tree.addCheckSelectionListener(new ICheckStateListener() { |
| @Override |
| public void fireNodeCheckStateChanged(ITreeNode node, boolean checkState) { |
| pingStateChanging(); |
| } |
| }); |
| m_treeListenersAttached = true; |
| } |
| // layout |
| parent.setLayout(new GridLayout(1, true)); |
| |
| GridData interfaceLocationData = new GridData(GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL | GridData.GRAB_VERTICAL | GridData.FILL_VERTICAL); |
| interfaceLocationData.heightHint = 200; |
| m_tree.setLayoutData(interfaceLocationData); |
| } |
| |
| /** |
| * @return the rootNode |
| */ |
| public ITreeNode getRootNode() { |
| return m_rootNode; |
| } |
| |
| private CheckableTree getTree() { |
| return m_tree; |
| } |
| |
| public void refreshTree() { |
| if (isControlCreated()) { |
| m_tree.getTreeViewer().refresh(); |
| } |
| } |
| |
| public IScoutBundle[] getLocationBundles(String type, boolean visibleOnly, boolean checkedOnly) { |
| ITreeNode[] nodes = getTreeNodes(type, visibleOnly, checkedOnly); |
| ArrayList<IScoutBundle> result = new ArrayList<IScoutBundle>(); |
| for (ITreeNode node : nodes) { |
| if (node != null && node.getParent() != null && node.getParent().getData() instanceof IScoutBundle) { |
| result.add((IScoutBundle) node.getParent().getData()); |
| } |
| } |
| return result.toArray(new IScoutBundle[result.size()]); |
| } |
| |
| public ITreeNode[] getTreeNodes(String type, boolean visibleOnly, boolean checkedOnly) { |
| ArrayList<ITreeNode> result = new ArrayList<ITreeNode>(); |
| if (isControlCreated()) { |
| ITreeNode[] nodes = TreeUtility.findNodes(m_rootNode, NodeFilters.getByType(type)); |
| for (ITreeNode node : nodes) { |
| if (node != null && checkedOnly && node.isCheckable()) { |
| if (!getTree().isChecked(node)) { |
| continue; |
| } |
| } |
| if (node != null && visibleOnly) { |
| if (!node.isVisible()) { |
| continue; |
| } |
| } |
| result.add(node); |
| } |
| } |
| return result.toArray(new ITreeNode[result.size()]); |
| } |
| |
| public static IScoutBundle getLocationBundle(ITreeNode node) { |
| ITreeNode searchNode = node; |
| IScoutBundle bundle = null; |
| while (bundle == null && searchNode != null) { |
| Object o = searchNode.getData(); |
| if (o instanceof IScoutBundle) { |
| return (IScoutBundle) o; |
| } |
| searchNode = searchNode.getParent(); |
| } |
| return null; |
| } |
| |
| public IScoutBundle getLocationBundle(String type, boolean visibleOnly, boolean checkedOnly) { |
| ITreeNode node = getTreeNode(type, visibleOnly, checkedOnly); |
| return getLocationBundle(node); |
| } |
| |
| public ITreeNode getTreeNode(String type, boolean visibleOnly, boolean checkedOnly) { |
| ITreeNode node = null; |
| if (isControlCreated()) { |
| node = TreeUtility.findNode(m_rootNode, NodeFilters.getByType(type)); |
| if (node != null) { |
| if (node.isCheckable() && checkedOnly && !getTree().isChecked(node)) { |
| return null; |
| } |
| if (visibleOnly && !node.isVisible()) { |
| return null; |
| } |
| } |
| } |
| return node; |
| } |
| |
| /** |
| * @param nodeType |
| * @return |
| */ |
| public String getTextOfNode(String nodeType) { |
| return getTextOfNode(nodeType, true, true); |
| } |
| |
| public String getTextOfNode(String type, boolean visibleOnly, boolean checkedOnly) { |
| ITreeNode treeNode = getTreeNode(type, visibleOnly, checkedOnly); |
| String text = null; |
| if (treeNode != null) { |
| text = treeNode.getText(); |
| } |
| return text; |
| } |
| |
| public boolean isNodeChecked(ITreeNode node) { |
| return m_tree.isChecked(node); |
| } |
| |
| public void setNodeChecked(ITreeNode node, boolean checked) { |
| m_tree.setChecked(node, checked); |
| } |
| } |