From 5e4034b5cba89460a62fa958fc78c2b85acb3d5f Mon Sep 17 00:00:00 2001 From: Andrew Branson Date: Tue, 7 Oct 2014 09:18:33 +0200 Subject: Repackage to org.cristalise --- src/main/java/org/cristalise/gui/tree/Node.java | 252 +++++++++++++++++++++ .../java/org/cristalise/gui/tree/NodeAgent.java | 33 +++ .../org/cristalise/gui/tree/NodeCollection.java | 144 ++++++++++++ .../java/org/cristalise/gui/tree/NodeContext.java | 66 ++++++ .../java/org/cristalise/gui/tree/NodeItem.java | 241 ++++++++++++++++++++ .../java/org/cristalise/gui/tree/NodeRole.java | 34 +++ .../org/cristalise/gui/tree/NodeSubscriber.java | 13 ++ .../cristalise/gui/tree/NodeTransferHandler.java | 74 ++++++ 8 files changed, 857 insertions(+) create mode 100644 src/main/java/org/cristalise/gui/tree/Node.java create mode 100644 src/main/java/org/cristalise/gui/tree/NodeAgent.java create mode 100644 src/main/java/org/cristalise/gui/tree/NodeCollection.java create mode 100644 src/main/java/org/cristalise/gui/tree/NodeContext.java create mode 100644 src/main/java/org/cristalise/gui/tree/NodeItem.java create mode 100644 src/main/java/org/cristalise/gui/tree/NodeRole.java create mode 100644 src/main/java/org/cristalise/gui/tree/NodeSubscriber.java create mode 100644 src/main/java/org/cristalise/gui/tree/NodeTransferHandler.java (limited to 'src/main/java/org/cristalise/gui/tree') diff --git a/src/main/java/org/cristalise/gui/tree/Node.java b/src/main/java/org/cristalise/gui/tree/Node.java new file mode 100644 index 0000000..4ef3942 --- /dev/null +++ b/src/main/java/org/cristalise/gui/tree/Node.java @@ -0,0 +1,252 @@ +package org.cristalise.gui.tree; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; + +import javax.swing.Icon; +import javax.swing.ImageIcon; +import javax.swing.JMenuItem; +import javax.swing.JPopupMenu; +import javax.swing.tree.DefaultMutableTreeNode; + +import org.cristalise.gui.DynamicTreeBuilder; +import org.cristalise.gui.ImageLoader; +import org.cristalise.gui.ItemTabManager; +import org.cristalise.kernel.common.ObjectNotFoundException; +import org.cristalise.kernel.lookup.AgentPath; +import org.cristalise.kernel.lookup.ItemPath; +import org.cristalise.kernel.lookup.Path; +import org.cristalise.kernel.lookup.RolePath; +import org.cristalise.kernel.process.Gateway; +import org.cristalise.kernel.utils.Language; +import org.cristalise.kernel.utils.Logger; + + +public abstract class Node implements Runnable { + + protected Path binding; + protected DefaultMutableTreeNode treeNode; + protected String name; // domain key + protected ItemPath itemPath; // target item + // attributes + protected String type = ""; + protected String toolTip = null; + protected Icon icon; + protected boolean isExpandable = false; + protected HashMap childNodes = new HashMap(); + protected ArrayList subscribers = new ArrayList(); + protected DynamicTreeBuilder loader = null; + private boolean loaded = false; + private String iconName; + protected ItemTabManager desktop; + static ImageIcon folder = ImageLoader.findImage("folder.png"); + static ImageIcon emptyLeaf = ImageLoader.findImage("leaf.png"); + + public Node(ItemTabManager desktop) { + this.desktop = desktop; + } + + protected void createTreeNode() { + this.treeNode = new DefaultMutableTreeNode(this); + } + + public Node(Path path, ItemTabManager desktop) { + this.binding = path; + this.desktop = desktop; + try { + this.itemPath = path.getItemPath(); + } catch (ObjectNotFoundException e) { } + // get the name of this node (last path element) + String[] pathComponents = path.getPath(); + if (pathComponents.length > 0) + this.name = pathComponents[pathComponents.length-1]; + else + this.name = Gateway.getProperties().getProperty("Name"); + } + + public ItemTabManager getDesktop() { + return desktop; + } + + public Node newNode(Path path) + { + try { + if (path.getItemPath() instanceof AgentPath) + return new NodeAgent(path, desktop); + else + return new NodeItem(path, desktop); + } catch (ObjectNotFoundException ex) { + if (path instanceof RolePath) + return new NodeRole(path, desktop); + return new NodeContext(path, desktop); + } + + } + + /** Inserts a tree builder as the first child of the node, so it can be opened in the tree + */ + public void makeExpandable() { + if (isExpandable) return; + loader = new DynamicTreeBuilder(this.treeNode, desktop); + this.treeNode.insert(loader.getTreeNode(),0); + isExpandable = true; + } + + + public DefaultMutableTreeNode getTreeNode() { + return treeNode; + } + + public void setTreeNode(DefaultMutableTreeNode treeNode) { + this.treeNode = treeNode; + treeNode.setUserObject(this); + } + + /** Subscription for loading node children. + * Note this is separate from the itemproxy subscription as it included query of the naming service + * and eventually should not require access to the item at all for higher performance */ + public void subscribeNode(NodeSubscriber target) { + subscribers.add(target); + if (loaded == false) { + loaded = true; + loadMore(); + } + else { + synchronized (childNodes) { + Node newNode; + for (Iterator nodes = childNodes.values().iterator(); nodes.hasNext();) { + newNode = nodes.next(); + Logger.msg("subscribeNode target.add("+newNode.name+")"); + target.add(newNode); + } + } + } + } + + public void loadMore() { + Thread loading = new Thread(this); + loading.start(); + } + + public void unsubscribeNode(NodeSubscriber target) { + subscribers.remove(target); + } + + public void add(Node newNode) { + synchronized(childNodes) { + childNodes.put(newNode.getPath(), newNode); + for (NodeSubscriber thisSub : subscribers) { + thisSub.add(newNode); + } + } + } + + public void remove(Path oldPath) { + synchronized(childNodes) { + childNodes.remove(oldPath); + for (NodeSubscriber thisSub : subscribers) { + thisSub.remove(oldPath); + } + } + } + + public void removeAllChildren() { + synchronized(childNodes) { + while (childNodes.keySet().iterator().hasNext()) { + remove(childNodes.keySet().iterator().next()); + } + } + } + + public Node getChildNode(Path itsPath) { + for (Iterator i = childNodes.keySet().iterator(); i.hasNext();) { + Object next = i.next(); + if ( next.equals(itsPath) ) return childNodes.get(next); + } + return null; + } + + // end of current batch + public void end(boolean more) { + for (NodeSubscriber thisSub : subscribers) { + thisSub.end(more); + } + } + + + @Override + public void run() { + Thread.currentThread().setName("Node Loader: "+name); + loadChildren(); + } + + public abstract void loadChildren(); + + public void refresh() { + removeAllChildren(); + loadChildren(); + } + + // Getters and Setters + + public ItemPath getItemPath() { return itemPath; } +// public void setSysKey( int sysKey ) { this.sysKey = sysKey; } + + public String getName() { return name; } +// public void setName( String name ) { this.name = name; } + + public String getType() { return type; } +// public void setType( String type ) { this.type = type; } + + public Path getPath() { return binding; } + + public DynamicTreeBuilder getTreeBuilder() { return loader; } + + @Override + public String toString() { + if (this.name.length() > 0) { + return this.name; + } + else { return "Cristal"; } + } + + public Icon getIcon() { + if (icon != null) return icon; + return(isExpandable?folder:emptyLeaf); + } + + public String getIconName() { + return iconName; + } + + public void setIcon(String icon) { + iconName = icon; + this.icon = ImageLoader.findImage("typeicons/"+icon+"_16.png"); + if (this.icon==ImageLoader.nullImg) this.icon = ImageLoader.findImage("typeicons/item_16.png"); + } + + public JPopupMenu getPopupMenu() { + JPopupMenu popup = new JPopupMenu(); + JMenuItem menuItem = new JMenuItem(Language.translate("Refresh")); + menuItem.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + if (isExpandable) refresh(); + } + }); + popup.add(menuItem); + return popup; + } + + public String getToolTip() { + if (toolTip != null && toolTip.length()>0) + return toolTip; + else + return type; + } + + public void setToolTip(String tip) { + this.toolTip = tip; + }} diff --git a/src/main/java/org/cristalise/gui/tree/NodeAgent.java b/src/main/java/org/cristalise/gui/tree/NodeAgent.java new file mode 100644 index 0000000..b070c5d --- /dev/null +++ b/src/main/java/org/cristalise/gui/tree/NodeAgent.java @@ -0,0 +1,33 @@ + +package org.cristalise.gui.tree; + + +import java.util.ArrayList; + +import org.cristalise.gui.ItemTabManager; +import org.cristalise.kernel.lookup.Path; + + +/** + * Structure for Item presence on the tree and ItemDetails boxes. Created by NodeFactory. + * @author $Author: abranson $ + * @version $Version$ + */ +public class NodeAgent extends NodeItem { + + public NodeAgent(Path path, ItemTabManager desktop) { + super(path, desktop); + } + + @Override + public void loadChildren() { + } + + @Override + public ArrayList getTabs() { + + ArrayList requiredTabs = super.getTabs(); + requiredTabs.add("JobList"); + return requiredTabs; + } +} diff --git a/src/main/java/org/cristalise/gui/tree/NodeCollection.java b/src/main/java/org/cristalise/gui/tree/NodeCollection.java new file mode 100644 index 0000000..3a8643a --- /dev/null +++ b/src/main/java/org/cristalise/gui/tree/NodeCollection.java @@ -0,0 +1,144 @@ +package org.cristalise.gui.tree; + +import java.util.ArrayList; + +import javax.swing.tree.DefaultMutableTreeNode; + +import org.cristalise.gui.ItemTabManager; +import org.cristalise.gui.MainFrame; +import org.cristalise.kernel.collection.Collection; +import org.cristalise.kernel.collection.CollectionMember; +import org.cristalise.kernel.collection.Dependency; +import org.cristalise.kernel.common.ObjectNotFoundException; +import org.cristalise.kernel.entity.proxy.ItemProxy; +import org.cristalise.kernel.entity.proxy.MemberSubscription; +import org.cristalise.kernel.entity.proxy.ProxyObserver; +import org.cristalise.kernel.lookup.ItemPath; +import org.cristalise.kernel.lookup.Path; +import org.cristalise.kernel.persistency.ClusterStorage; +import org.cristalise.kernel.utils.CastorHashMap; +import org.cristalise.kernel.utils.KeyValuePair; +import org.cristalise.kernel.utils.Logger; + + +public class NodeCollection extends Node implements ProxyObserver> { + + ItemProxy parent; + Collection thisCollection; + String path; + + public NodeCollection(ItemProxy parent, String name, ItemTabManager desktop) { + super(desktop); + this.parent = parent; + this.name = name; + this.path = parent.getPath()+"/"+ClusterStorage.COLLECTION+"/"+name+"/last"; + createTreeNode(); + this.makeExpandable(); + } + + public NodeCollection(ItemProxy parent, Collection coll, ItemTabManager desktop) { + super(desktop); + this.parent = parent; + this.name = coll.getName(); + this.path = parent.getPath()+"/"+ClusterStorage.COLLECTION+"/"+name+"/last"; + createTreeNode(); + this.makeExpandable(); + add(coll); + } + + @Override + public void loadChildren() { + Logger.msg(8, "NodeCollection::loadChildren()"); + try { + if (thisCollection == null) { + Collection initColl = (Collection)parent.getObject(ClusterStorage.COLLECTION+"/"+name+"/last"); + add(initColl); + } + parent.subscribe(new MemberSubscription>(this, ClusterStorage.COLLECTION, false)); + } catch (ObjectNotFoundException ex) { + end(false); + return; + } + } + + @Override + public void add(Collection contents) { + if (!contents.getName().equals(name)) return; + this.type = contents.getClass().getSimpleName(); + ArrayList newMembers = contents.getMembers().list; + ArrayList oldMembers; + if (thisCollection == null) + oldMembers = new ArrayList(); + else + oldMembers = thisCollection.getMembers().list; + + ArrayList currentPaths = new ArrayList(); + // add any missing paths + for (CollectionMember newMember : newMembers) { + ItemPath itemPath = newMember.getItemPath(); + if (!oldMembers.contains(newMember) && itemPath != null) { + currentPaths.add(itemPath); + NodeItem newMemberNode = new NodeItem(itemPath, desktop); + newMemberNode.setCollection(contents, newMember.getID(), parent); + newMemberNode.setToolTip(getPropertyToolTip(newMember.getProperties())); + add(newMemberNode); + } + } + // remove those no longer present + for (Path childPath : childNodes.keySet()) { + if (!currentPaths.contains(childPath)) { + remove(childPath); + } + + } + + thisCollection = contents; + if (isDependency()) + setToolTip(getPropertyToolTip(((Dependency)contents).getProperties())); + end(false); + } + + public boolean addMember(ItemPath itemPath) { + if (!isDependency()) return false; + String[] params = { thisCollection.getName(), itemPath.getUUID().toString() }; + try { + MainFrame.userAgent.execute(parent, "AddMemberToCollection", params); + return true; + } catch (Exception e1) { + MainFrame.exceptionDialog(e1); + return false; + } + } + + public static String getPropertyToolTip(CastorHashMap props) { + if (props.size() == 0) return null; + StringBuffer verStr = new StringBuffer(""); + for (KeyValuePair prop : props.getKeyValuePairs()) { + verStr.append("").append(prop.getKey()).append(": ").append(prop.getValue()).append("
"); + } + return verStr.append("").toString(); + } + + @Override + public DefaultMutableTreeNode getTreeNode() { + return treeNode; + } + + + + @Override + public void remove(String id) { + // TODO Auto-generated method stub + + } + + @Override + public void control(String control, String msg) { + // TODO Auto-generated method stub + + } + + public boolean isDependency() { + return thisCollection instanceof Dependency; + } +} diff --git a/src/main/java/org/cristalise/gui/tree/NodeContext.java b/src/main/java/org/cristalise/gui/tree/NodeContext.java new file mode 100644 index 0000000..97252c7 --- /dev/null +++ b/src/main/java/org/cristalise/gui/tree/NodeContext.java @@ -0,0 +1,66 @@ +package org.cristalise.gui.tree; + +import java.util.Iterator; + +import org.cristalise.gui.ItemTabManager; +import org.cristalise.kernel.entity.proxy.DomainPathSubscriber; +import org.cristalise.kernel.lookup.DomainPath; +import org.cristalise.kernel.lookup.Path; +import org.cristalise.kernel.process.Gateway; +import org.cristalise.kernel.utils.Logger; + + + +public class NodeContext extends Node implements DomainPathSubscriber { + Iterator children; + + public NodeContext(Path path, ItemTabManager desktop) { + super(path, desktop); + this.itemPath = null; + createTreeNode(); + this.makeExpandable(); + this.type = "Cristal Context"; + } + + + @Override + public void loadChildren() { + if (children == null) { + Gateway.getProxyManager().subscribeTree(this, (DomainPath)binding); + children = Gateway.getLookup().getChildren(binding); + } + + int batch = 75; + while (children.hasNext() && batch > 0) { + Path newPath = children.next(); + if (newPath == null) break; + Logger.msg(2, "Subscription.run() - new node: " + newPath ); + add( newNode(newPath)); + batch--; + } + end(children.hasNext()); + } + + @Override + public void pathAdded(DomainPath path) { + add(newNode(path)); + } + + @Override + public void refresh() { + children = null; + super.refresh(); + } + @Override + public void pathRemoved(DomainPath path) { + remove(path); + } + +} + + + + + + + diff --git a/src/main/java/org/cristalise/gui/tree/NodeItem.java b/src/main/java/org/cristalise/gui/tree/NodeItem.java new file mode 100644 index 0000000..667b701 --- /dev/null +++ b/src/main/java/org/cristalise/gui/tree/NodeItem.java @@ -0,0 +1,241 @@ +package org.cristalise.gui.tree; + +import java.awt.datatransfer.DataFlavor; +import java.awt.datatransfer.Transferable; +import java.awt.datatransfer.UnsupportedFlavorException; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.io.IOException; +import java.util.ArrayList; +import java.util.StringTokenizer; + +import javax.swing.JMenuItem; +import javax.swing.JPopupMenu; + +import org.cristalise.gui.ItemDetails; +import org.cristalise.gui.ItemTabManager; +import org.cristalise.gui.MainFrame; +import org.cristalise.kernel.collection.Aggregation; +import org.cristalise.kernel.collection.Collection; +import org.cristalise.kernel.collection.CollectionMember; +import org.cristalise.kernel.common.ObjectNotFoundException; +import org.cristalise.kernel.entity.agent.Job; +import org.cristalise.kernel.entity.proxy.ItemProxy; +import org.cristalise.kernel.lookup.Path; +import org.cristalise.kernel.persistency.ClusterStorage; +import org.cristalise.kernel.process.Gateway; +import org.cristalise.kernel.utils.Language; +import org.cristalise.kernel.utils.Logger; + + +/** + * Structure for Item presence on the tree and ItemDetails boxes. Created by NodeFactory. + * @author $Author: abranson $ + * @version $Version$ + */ +public class NodeItem extends Node implements Transferable { + + protected ItemProxy myItem = null; + + public NodeItem(Path path, ItemTabManager desktop) { + + super(path, desktop); + Logger.msg(2,"NodeEntity. - Creating item for '"+path.toString()+"'."); + + // if an item - resolve the item and get its properties + try { + myItem = Gateway.getProxyManager().getProxy(path); + this.itemPath = path.getItemPath(); + Logger.msg(2,"NodeEntity. - System key is "+this.itemPath); + + // Name should be the alias if present + String alias = myItem.getName(); + if (alias != null) this.name = alias; + + try { + this.type = myItem.getProperty("Type"); + } catch (ObjectNotFoundException e) { + this.type = ""; + } + String iconString = this.type; + if (type.equals("ActivityDesc")) + try { + iconString = myItem.getProperty("Complexity")+iconString; + } catch (ObjectNotFoundException e) { + iconString = "error"; + } + iconString = iconString.toLowerCase(); + this.setIcon(iconString); + } catch (ObjectNotFoundException e1) { + this.itemPath = null; + this.type="Error"; + this.name="Entity not found"; + this.setIcon("error"); + } + createTreeNode(); + makeExpandable(); + } + + public ItemProxy getItem() { + return myItem; + } + + public void openItem() { + desktop.add(this); + } + + public Collection getParentCollection() { + return parentCollection; + } + + public Integer getSlotNo() { + return slotNo; + } + + Collection parentCollection; + Integer slotNo = null; + static DataFlavor dataFlavor = new DataFlavor(NodeItem.class, "NodeItem"); + ItemProxy parentItem; + static DataFlavor[] supportedFlavours = new DataFlavor[] { + dataFlavor, + new DataFlavor(Path.class, "Path"), + DataFlavor.getTextPlainUnicodeFlavor() }; + + + public void setCollection(Collection parentCollection, Integer slotNo, ItemProxy parentItem) { + this.parentCollection = parentCollection; + this.slotNo = slotNo; + this.parentItem = parentItem; + } + + @Override + public void loadChildren() { + try { + String collections = myItem.queryData("Collection/all"); + StringTokenizer tok = new StringTokenizer(collections, ","); + while (tok.hasMoreTokens()) { + NodeCollection newCollection = new NodeCollection(myItem, tok.nextToken(), desktop); + add(newCollection); + } + end(false); + } catch (Exception e) { + Logger.error(e); + } + } + + @Override + public JPopupMenu getPopupMenu() { + + JPopupMenu popup = super.getPopupMenu(); + JMenuItem openItem = new JMenuItem(Language.translate("Open")); + openItem.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + openItem(); + } + }); + popup.addSeparator(); + popup.add(openItem); + popup.addSeparator(); + if (parentCollection != null && MainFrame.isAdmin) { + JMenuItem collMenuItem = new JMenuItem("Remove from collection"); + //collMenuItem.setActionCommand("removeColl"); + collMenuItem.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + String[] params = { parentCollection.getName(), String.valueOf(slotNo) }; + String predefStepName = parentCollection instanceof Aggregation?"ClearSlot":"RemoveSlotFromCollection"; + try { + MainFrame.userAgent.execute(parentItem, predefStepName, params); + } catch (Exception e1) { + MainFrame.exceptionDialog(e1); + } + + } + }); + popup.add(collMenuItem); + popup.addSeparator(); + } + try { + ArrayList jobList = myItem.getJobList(MainFrame.userAgent); + ArrayList already = new ArrayList(); + if (jobList.size() > 0) { + for (Job thisJob : jobList) { + String stepName = thisJob.getStepName(); + if (already.contains(stepName)) + continue; + already.add(stepName); + JMenuItem menuItem = new JMenuItem(stepName); + menuItem.setActionCommand(stepName); + menuItem.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent e) { + execute(e.getActionCommand()); + } + }); + popup.add(menuItem); + + } + } + else { + JMenuItem noAct = new JMenuItem("No activities"); + noAct.setEnabled(false); + popup.add(noAct); + } + } catch (Exception ex) { + JMenuItem error = new JMenuItem("Error querying jobs"); + error.setEnabled(false); + popup.add(error); + } + + return popup; + } + + public void execute(String stepName) { + ItemDetails thisDetail = desktop.add(this); + thisDetail.runCommand("Execution", stepName); + } + + public ArrayList getTabs() { + + ArrayList requiredTabs = new ArrayList(); + requiredTabs.add("Properties"); + try { + String collNames = myItem.queryData(ClusterStorage.COLLECTION+"/all"); + if (collNames.length() > 0) + requiredTabs.add("Collection"); + } catch (Exception e) { } + requiredTabs.add("Execution"); + requiredTabs.add("History"); + requiredTabs.add("Viewpoint"); + requiredTabs.add("Workflow"); + return requiredTabs; + + } + + @Override + public DataFlavor[] getTransferDataFlavors() { + return supportedFlavours; + } + + @Override + public boolean isDataFlavorSupported(DataFlavor flavor) { + for (DataFlavor flavour : supportedFlavours) { + if (flavour.equals(flavor)) + return true; + } + return false; + } + + @Override + public Object getTransferData(DataFlavor flavor) + throws UnsupportedFlavorException, IOException { + if (flavor.equals(supportedFlavours[0])) + return this; + if (flavor.equals(supportedFlavours[1])) + return binding; + if (flavor.equals(supportedFlavours[2])) + return name; + throw new UnsupportedFlavorException(flavor); + } +} diff --git a/src/main/java/org/cristalise/gui/tree/NodeRole.java b/src/main/java/org/cristalise/gui/tree/NodeRole.java new file mode 100644 index 0000000..288d3b6 --- /dev/null +++ b/src/main/java/org/cristalise/gui/tree/NodeRole.java @@ -0,0 +1,34 @@ +package org.cristalise.gui.tree; + +import org.cristalise.gui.ItemTabManager; +import org.cristalise.kernel.common.ObjectNotFoundException; +import org.cristalise.kernel.lookup.AgentPath; +import org.cristalise.kernel.lookup.Path; +import org.cristalise.kernel.lookup.RolePath; +import org.cristalise.kernel.process.Gateway; +import org.cristalise.kernel.utils.Logger; + + +public class NodeRole extends NodeContext { + + RolePath role; + public NodeRole(Path path, ItemTabManager desktop) { + super(path, desktop); + role = (RolePath)path; + } + @Override + public void loadChildren() { + AgentPath[] agents; + try { + agents = Gateway.getLookup().getAgents(role); + for (AgentPath agentPath : agents) { + add (newNode(agentPath)); + } + } catch (ObjectNotFoundException e) { + Logger.error("Role "+role.getName()+" not found"); + } + super.loadChildren(); + } + + +} diff --git a/src/main/java/org/cristalise/gui/tree/NodeSubscriber.java b/src/main/java/org/cristalise/gui/tree/NodeSubscriber.java new file mode 100644 index 0000000..b06f497 --- /dev/null +++ b/src/main/java/org/cristalise/gui/tree/NodeSubscriber.java @@ -0,0 +1,13 @@ +package org.cristalise.gui.tree; + +import org.cristalise.kernel.lookup.Path; + + +public interface NodeSubscriber { + + public void add(Node newNode); + + public void remove(Path path); + + public void end(boolean more); +} diff --git a/src/main/java/org/cristalise/gui/tree/NodeTransferHandler.java b/src/main/java/org/cristalise/gui/tree/NodeTransferHandler.java new file mode 100644 index 0000000..89f503c --- /dev/null +++ b/src/main/java/org/cristalise/gui/tree/NodeTransferHandler.java @@ -0,0 +1,74 @@ +package org.cristalise.gui.tree; + +import java.awt.datatransfer.Transferable; + +import javax.swing.Icon; +import javax.swing.JComponent; +import javax.swing.TransferHandler; + +import org.cristalise.gui.ImageLoader; +import org.cristalise.gui.MainFrame; +import org.cristalise.gui.TreeBrowser; +import org.cristalise.kernel.utils.Logger; + + +public class NodeTransferHandler extends TransferHandler { + + TreeBrowser tree; + + public NodeTransferHandler(TreeBrowser treeBrowser) { + tree = treeBrowser; + } + + @Override + public int getSourceActions(JComponent c) { + return COPY_OR_MOVE; + } + + @Override + public Transferable createTransferable(JComponent c) { + Node selNode = tree.getSelectedNode(); + if (selNode instanceof Transferable) + return (Transferable)selNode; + else + return null; + } + + @Override + public boolean importData(TransferSupport support) { + if (!canImport(support)) { + return false; + } + Node dropNode = tree.getNodeAt(support.getDropLocation().getDropPoint()); + if (dropNode instanceof NodeCollection) { + NodeCollection collNode = (NodeCollection)dropNode; + NodeItem source; + try { + source = (NodeItem)support.getTransferable().getTransferData(NodeItem.dataFlavor); + return collNode.addMember(source.getItemPath()); + } catch (Exception e) { + Logger.error(e); + return false; + } + } + return super.importData(support); + } + + @Override + public boolean canImport(TransferSupport support) { + boolean isNode = support.isDataFlavorSupported(NodeItem.dataFlavor); + if (!isNode) return false; + Node dropNode = tree.getNodeAt(support.getDropLocation().getDropPoint()); + if (MainFrame.isAdmin && dropNode instanceof NodeCollection && ((NodeCollection)dropNode).isDependency()) + return true; + return false; + + } + + @Override + public Icon getVisualRepresentation(Transferable t) { + if (t instanceof NodeItem) + return (((NodeItem)t).getIcon()); + return ImageLoader.nullImg; + } +} -- cgit v1.2.3