From af80bd2426282b7491d9ba0ebfb201abb42e3ca4 Mon Sep 17 00:00:00 2001 From: geronimo Date: Wed, 15 Aug 2012 07:55:07 +0200 Subject: next variant of java client --- .../control/dnd/FilelistTransferable.java | 72 +++++++ .../dnd/ListSelectionSourceTransferHandler.java | 69 +++++++ .../control/dnd/TreePathTransferable.java | 74 ++++++++ .../dnd/TreeSourceAndDestTransferHandler.java | 207 +++++++++++++++++++++ 4 files changed, 422 insertions(+) create mode 100644 cmpcj/src/de/schwarzrot/control/dnd/FilelistTransferable.java create mode 100644 cmpcj/src/de/schwarzrot/control/dnd/ListSelectionSourceTransferHandler.java create mode 100644 cmpcj/src/de/schwarzrot/control/dnd/TreePathTransferable.java create mode 100644 cmpcj/src/de/schwarzrot/control/dnd/TreeSourceAndDestTransferHandler.java (limited to 'cmpcj/src/de/schwarzrot/control/dnd') diff --git a/cmpcj/src/de/schwarzrot/control/dnd/FilelistTransferable.java b/cmpcj/src/de/schwarzrot/control/dnd/FilelistTransferable.java new file mode 100644 index 0000000..678bbc1 --- /dev/null +++ b/cmpcj/src/de/schwarzrot/control/dnd/FilelistTransferable.java @@ -0,0 +1,72 @@ +/** + * ======================== legal notice ====================== + * + * File: FilelistTransferable.java + * Created: 13. June 2012, 04:57 + * Author: Geronimo + * Project: cmpc - a java frontend (client) part of compound media player + * uses external players to play the media + * + * CMP - compound media player + * + * is a client/server mediaplayer intended to play any media from any workstation + * without the need to export or mount shares. cmps is an easy to use backend + * with a (ready to use) HTML-interface. Additionally the backend supports + * authentication via HTTP-digest authorization. + * cmpc is a client with vdr-like osd-menues. + * + * Copyright (c) 2012 Reinhard Mantey, some rights reserved! + * published under Creative Commons by-sa + * For details see http://creativecommons.org/licenses/by-sa/3.0/ + * + * The cmp project's homepage is at http://projects.vdr-developer.org/projects/cmp + * + * -------------------------------------------------------------- + */ +package de.schwarzrot.control.dnd; + + +import java.awt.datatransfer.DataFlavor; +import java.awt.datatransfer.Transferable; +import java.awt.datatransfer.UnsupportedFlavorException; +import java.io.File; +import java.io.IOException; +import java.util.List; + + +public class FilelistTransferable implements Transferable { + public FilelistTransferable(List fileList) { + files = fileList; + } + + + protected FilelistTransferable() { + } + + + @Override + public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException { + if (DataFlavor.javaFileListFlavor.equals(flavor)) + return files; + throw new UnsupportedFlavorException(flavor); + } + + + @Override + public DataFlavor[] getTransferDataFlavors() { + return new DataFlavor[] { DataFlavor.javaFileListFlavor }; + } + + + @Override + public boolean isDataFlavorSupported(DataFlavor flavor) { + return DataFlavor.javaFileListFlavor.equals(flavor); + } + + + protected void setFileList(List list) { + files = list; + } + + private List files; +} diff --git a/cmpcj/src/de/schwarzrot/control/dnd/ListSelectionSourceTransferHandler.java b/cmpcj/src/de/schwarzrot/control/dnd/ListSelectionSourceTransferHandler.java new file mode 100644 index 0000000..e396e17 --- /dev/null +++ b/cmpcj/src/de/schwarzrot/control/dnd/ListSelectionSourceTransferHandler.java @@ -0,0 +1,69 @@ +/** + * ======================== legal notice ====================== + * + * File: ListSelectionSourceTransferHandler.java + * Created: 13. June 2012, 04:57 + * Author: Geronimo + * Project: cmpc - a java frontend (client) part of compound media player + * uses external players to play the media + * + * CMP - compound media player + * + * is a client/server mediaplayer intended to play any media from any workstation + * without the need to export or mount shares. cmps is an easy to use backend + * with a (ready to use) HTML-interface. Additionally the backend supports + * authentication via HTTP-digest authorization. + * cmpc is a client with vdr-like osd-menues. + * + * Copyright (c) 2012 Reinhard Mantey, some rights reserved! + * published under Creative Commons by-sa + * For details see http://creativecommons.org/licenses/by-sa/3.0/ + * + * The cmp project's homepage is at http://projects.vdr-developer.org/projects/cmp + * + * -------------------------------------------------------------- + */ +package de.schwarzrot.control.dnd; + + +import java.awt.datatransfer.Transferable; +import java.io.File; +import java.util.ArrayList; +import java.util.List; +import javax.swing.JComponent; +import javax.swing.TransferHandler; +import ca.odell.glazedlists.EventList; +import ca.odell.glazedlists.swing.DefaultEventSelectionModel; +import de.schwarzrot.media.domain.Media; + + +public class ListSelectionSourceTransferHandler extends TransferHandler { + private static final long serialVersionUID = 713L; + + + public ListSelectionSourceTransferHandler(DefaultEventSelectionModel selectionModel) { + sm = selectionModel; + } + + + @Override + public Transferable createTransferable(JComponent c) { + if (sm.isSelectionEmpty()) + return null; + EventList selection = sm.getSelected(); + List transferList = new ArrayList(); + + for (Media m : selection) { + transferList.add(m.getRealPath()); + } + return new FilelistTransferable(transferList); + } + + + @Override + public int getSourceActions(JComponent c) { + return TransferHandler.LINK; + } + + private DefaultEventSelectionModel sm; +} diff --git a/cmpcj/src/de/schwarzrot/control/dnd/TreePathTransferable.java b/cmpcj/src/de/schwarzrot/control/dnd/TreePathTransferable.java new file mode 100644 index 0000000..a54be35 --- /dev/null +++ b/cmpcj/src/de/schwarzrot/control/dnd/TreePathTransferable.java @@ -0,0 +1,74 @@ +/** + * ======================== legal notice ====================== + * + * File: TreePathTransferable.java + * Created: 13. June 2012, 04:57 + * Author: Geronimo + * Project: cmpc - a java frontend (client) part of compound media player + * uses external players to play the media + * + * CMP - compound media player + * + * is a client/server mediaplayer intended to play any media from any workstation + * without the need to export or mount shares. cmps is an easy to use backend + * with a (ready to use) HTML-interface. Additionally the backend supports + * authentication via HTTP-digest authorization. + * cmpc is a client with vdr-like osd-menues. + * + * Copyright (c) 2012 Reinhard Mantey, some rights reserved! + * published under Creative Commons by-sa + * For details see http://creativecommons.org/licenses/by-sa/3.0/ + * + * The cmp project's homepage is at http://projects.vdr-developer.org/projects/cmp + * + * -------------------------------------------------------------- + */ +package de.schwarzrot.control.dnd; + + +import java.awt.datatransfer.DataFlavor; +import java.awt.datatransfer.Transferable; +import java.awt.datatransfer.UnsupportedFlavorException; +import java.io.IOException; +import javax.swing.tree.TreePath; + + +public class TreePathTransferable implements Transferable { + public static final DataFlavor TreePathFlavor; + + + public TreePathTransferable(TreePath path) { + data = path; + } + + + @Override + public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException { + if (TreePathFlavor.equals(flavor)) + return data; + throw new UnsupportedFlavorException(flavor); + } + + + @Override + public DataFlavor[] getTransferDataFlavors() { + return new DataFlavor[] { TreePathFlavor }; + } + + + @Override + public boolean isDataFlavorSupported(DataFlavor flavor) { + return TreePathFlavor.equals(flavor); + } + + private TreePath data; + static { + DataFlavor tmp = null; + + try { + tmp = new DataFlavor(DataFlavor.javaJVMLocalObjectMimeType + ";class=" + TreePath.class.getName()); + } catch (ClassNotFoundException e) { + } + TreePathFlavor = tmp; + } +} diff --git a/cmpcj/src/de/schwarzrot/control/dnd/TreeSourceAndDestTransferHandler.java b/cmpcj/src/de/schwarzrot/control/dnd/TreeSourceAndDestTransferHandler.java new file mode 100644 index 0000000..d9c3285 --- /dev/null +++ b/cmpcj/src/de/schwarzrot/control/dnd/TreeSourceAndDestTransferHandler.java @@ -0,0 +1,207 @@ +/** + * ======================== legal notice ====================== + * + * File: TreeSourceAndDestTransferHandler.java + * Created: 13. June 2012, 04:57 + * Author: Geronimo + * Project: cmpc - a java frontend (client) part of compound media player + * uses external players to play the media + * + * CMP - compound media player + * + * is a client/server mediaplayer intended to play any media from any workstation + * without the need to export or mount shares. cmps is an easy to use backend + * with a (ready to use) HTML-interface. Additionally the backend supports + * authentication via HTTP-digest authorization. + * cmpc is a client with vdr-like osd-menues. + * + * Copyright (c) 2012 Reinhard Mantey, some rights reserved! + * published under Creative Commons by-sa + * For details see http://creativecommons.org/licenses/by-sa/3.0/ + * + * The cmp project's homepage is at http://projects.vdr-developer.org/projects/cmp + * + * -------------------------------------------------------------- + */ +package de.schwarzrot.control.dnd; + + +import java.awt.datatransfer.DataFlavor; +import java.awt.datatransfer.Transferable; +import java.io.File; +import java.util.List; +import java.util.Map; +import javax.swing.JComponent; +import javax.swing.JTree; +import javax.swing.TransferHandler; +import javax.swing.tree.DefaultMutableTreeNode; +import javax.swing.tree.TreePath; +import ca.odell.glazedlists.EventList; +import de.schwarzrot.media.domain.AbstractMediaNode; +import de.schwarzrot.media.domain.Genre; +import de.schwarzrot.media.domain.Media; + + +public class TreeSourceAndDestTransferHandler extends TransferHandler { + private static final long serialVersionUID = 713L; + + + public TreeSourceAndDestTransferHandler(JTree tree, Map cache, + EventList changes) { + this.tree = tree; + nodeCache = cache; + this.changes = changes; + } + + + // dest + @Override + public boolean canImport(TransferHandler.TransferSupport support) { + if (!support.isDrop()) + return false; + support.setShowDropLocation(true); + + if (support.isDataFlavorSupported(TreePathTransferable.TreePathFlavor) && support.getDropAction() == MOVE) + return true; + if (support.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) + return true; + + return false; + } + + + // source + @Override + public Transferable createTransferable(JComponent c) { + if (c != tree) + return null; + TreePath selectionPath = tree.getSelectionPath(); + + return new TreePathTransferable(selectionPath); + } + + + // source + @Override + public void exportDone(JComponent c, Transferable data, int action) { + tree.updateUI(); + } + + + // source + @Override + public int getSourceActions(JComponent c) { + return MOVE; + } + + + // dest + @Override + public boolean importData(TransferHandler.TransferSupport support) { + if (!canImport(support)) + return false; + JTree.DropLocation dl = (JTree.DropLocation) support.getDropLocation(); + TreePath targetPath = tree.getClosestPathForLocation(dl.getDropPoint().x, dl.getDropPoint().y); + DefaultMutableTreeNode targetNode = (DefaultMutableTreeNode) targetPath.getLastPathComponent(); + + if (support.isDataFlavorSupported(TreePathTransferable.TreePathFlavor)) { + // move a genre in tree + try { + TreePath sourcePath = (TreePath) support.getTransferable().getTransferData( + TreePathTransferable.TreePathFlavor); + DefaultMutableTreeNode transferNode = (DefaultMutableTreeNode) sourcePath.getLastPathComponent(); + DefaultMutableTreeNode sourceParentNode = (DefaultMutableTreeNode) transferNode.getParent(); + Genre target = (Genre) targetNode.getUserObject(); + Genre transfer = (Genre) transferNode.getUserObject(); + + // System.out.println("importData() targetPath: " + targetPath); + // System.out.println("importData() sourcePath: " + sourcePath); + + sourceParentNode.remove(transferNode); + targetNode.add(transferNode); + nodeCache.remove(transfer.getRealPath()); + // System.out.println("old path of genre to move: " + transfer.getRealPath().getAbsolutePath()); + transfer.setParent(target); + // System.out.println("new path of moved genre: " + transfer.getRealPath().getAbsolutePath()); + nodeCache.put(transfer.getRealPath(), transferNode); + transfer.update(); + refreshNodeCache(); + if (!changes.contains(transfer)) { + changes.getReadWriteLock().writeLock().lock(); + changes.add(transfer); + changes.getReadWriteLock().writeLock().unlock(); + } + } catch (Throwable t) { + t.printStackTrace(); + } + } else if (support.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) { + // move media files from one genre to another (no visible tree change) + try { + @SuppressWarnings("unchecked") + List fileList = (List) support.getTransferable().getTransferData( + DataFlavor.javaFileListFlavor); + + for (File f : fileList) + move2TargetNode(targetNode, f); // each media can have different parent, so don't optimize here + } catch (Throwable t) { + t.printStackTrace(); + } + } + return false; + } + + + protected void cacheNode(DefaultMutableTreeNode node) { + Genre g = (Genre) node.getUserObject(); + + nodeCache.put(g.getRealPath(), node); + for (int i = 0; i < node.getChildCount(); ++i) { + DefaultMutableTreeNode sub = (DefaultMutableTreeNode) node.getChildAt(i); + + cacheNode(sub); + } + } + + + protected void move2TargetNode(DefaultMutableTreeNode targetNode, File mediaPath) { + if (targetNode == null || mediaPath == null) + return; + Genre targetGenre = (Genre) targetNode.getUserObject(); + DefaultMutableTreeNode node = nodeCache.get(mediaPath.getParentFile()); + + if (targetGenre != null && node != null) { + Media transferMedia = null; + Genre sourceGenre = (Genre) node.getUserObject(); + + for (Media m : sourceGenre.getMediaList()) { + if (m.getRealPath().equals(mediaPath)) { + transferMedia = m; + break; + } + } + + if (transferMedia != null) { + System.out.println("old path of media to transfer: " + transferMedia.getRealPath().getAbsolutePath()); + transferMedia.setParent(targetGenre); + System.out.println("new path of transferred media: " + transferMedia.getRealPath().getAbsolutePath()); + if (!changes.contains(transferMedia)) { + changes.getReadWriteLock().writeLock().lock(); + changes.add(transferMedia); + changes.getReadWriteLock().writeLock().unlock(); + } + } + } + } + + + protected void refreshNodeCache() { + nodeCache.clear(); + DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getModel().getRoot(); + + cacheNode(node); + } + + private JTree tree; + private EventList changes; + private Map nodeCache; +} -- cgit v1.2.3