KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > columba > mail > gui > tree > TreeViewTransferHandler


1 //The contents of this file are subject to the Mozilla Public License Version 1.1
2
//(the "License"); you may not use this file except in compliance with the
3
//License. You may obtain a copy of the License at http://www.mozilla.org/MPL/
4
//
5
//Software distributed under the License is distributed on an "AS IS" basis,
6
//WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
7
//for the specific language governing rights and
8
//limitations under the License.
9
//
10
//The Original Code is "The Columba Project"
11
//
12
//The Initial Developers of the Original Code are Frederik Dietz and Timo Stich.
13
//Portions created by Frederik Dietz and Timo Stich are Copyright (C) 2003.
14
//
15
//All Rights Reserved.
16
package org.columba.mail.gui.tree;
17
18 import java.awt.datatransfer.DataFlavor JavaDoc;
19 import java.awt.datatransfer.Transferable JavaDoc;
20
21 import javax.swing.JComponent JavaDoc;
22 import javax.swing.TransferHandler JavaDoc;
23 import javax.swing.tree.DefaultMutableTreeNode JavaDoc;
24 import javax.swing.tree.TreePath JavaDoc;
25
26 import org.columba.api.gui.frame.IFrameMediator;
27 import org.columba.core.command.CommandProcessor;
28 import org.columba.core.facade.DialogFacade;
29 import org.columba.mail.command.IMailFolderCommandReference;
30 import org.columba.mail.command.MailFolderCommandReference;
31 import org.columba.mail.folder.IMailFolder;
32 import org.columba.mail.folder.IMailbox;
33 import org.columba.mail.folder.command.CopyMessageCommand;
34 import org.columba.mail.folder.command.MoveFolderCommand;
35 import org.columba.mail.folder.command.MoveMessageCommand;
36 import org.columba.mail.gui.frame.MailFrameMediator;
37 import org.columba.mail.gui.table.MessageReferencesTransfer;
38
39 /**
40  * A Transferhandler for the TreeView. This handler will only work with a
41  * treeview component. The only type of folders that can be moved in the
42  * treeview are <code>VirtualFolder</code> and
43  * <code>AbstractLocalFolder</code>
44  * <p>
45  * The handler supports
46  * <ul>
47  * <li>Moving a folder into other folders. If the folder is a
48  * <code>VirtualFolder</code> or a <code>AbstractLocalFolder</code>.
49  * <li>Copying messages into one folder.
50  * </ul>
51  *
52  * @author redsolo
53  */

54 public class TreeViewTransferHandler extends TransferHandler JavaDoc {
55
56     private IFrameMediator frameMediator;
57
58     public TreeViewTransferHandler(IFrameMediator frameMediator) {
59         this.frameMediator = frameMediator;
60     }
61
62     /** {@inheritDoc} */
63     public boolean importData(JComponent JavaDoc comp, Transferable JavaDoc transferProxy) {
64         boolean dataWasImported = false;
65
66         if (comp instanceof TreeView) {
67             TreeView treeView = (TreeView) comp;
68
69             try {
70                 DataFlavor JavaDoc[] dataFlavors = transferProxy
71                         .getTransferDataFlavors();
72
73                 for (int i = 0; (i < dataFlavors.length) && (!dataWasImported); i++) {
74                     if (dataFlavors[i].equals(FolderTransfer.FLAVOR)) {
75                         dataWasImported = importFolderReferences(treeView,
76                                 (FolderTransfer) transferProxy
77                                         .getTransferData(FolderTransfer.FLAVOR));
78                     } else if (dataFlavors[i]
79                             .equals(MessageReferencesTransfer.FLAVOR)) {
80                         MessageReferencesTransfer messageTransferable = (MessageReferencesTransfer) transferProxy
81                                 .getTransferData(MessageReferencesTransfer.FLAVOR);
82                         dataWasImported = importMessageReferences(treeView,
83                                 messageTransferable);
84                     }
85                 }
86             } catch (Exception JavaDoc e) { // UnsupportedFlavorException, IOException
87
DialogFacade.showExceptionDialog(e);
88             }
89         }
90
91         return dataWasImported;
92     }
93
94     /**
95      * Try to import the folder references. Current implementation can only MOVE
96      * folders, it cannot copy them to a new destination. The actual MOVE call
97      * is done in the <code>exportDone()</code> method.
98      * <p>
99      * This method returns true if dragged folder and destination folder is not
100      * null.
101      *
102      * @param treeView
103      * the tree view to import data into.
104      * @param transferable
105      * the folder references.
106      * @return true if the folders could be imported; false otherwise.
107      */

108     private boolean importFolderReferences(TreeView treeView,
109             FolderTransfer transferable) {
110         boolean dataWasImported = false;
111
112         IMailFolder destFolder = treeView.getDropTargetFolder();
113         IMailbox draggedFolder = transferable.getFolderReference();
114
115         if ((destFolder != null) && (draggedFolder != null)) {
116             // We're always doing a MOVE
117
// and this is handled in the exportDone method.
118
dataWasImported = true;
119         }
120
121         return dataWasImported;
122     }
123
124     /**
125      * Try to import the message references. This method copies the messages to
126      * the new folder. Note that it will not delete them, since this is done by
127      * the transferhandler that initiated the drag.
128      *
129      * @param treeView
130      * the tree view to import data into.
131      * @param transferable
132      * the message references.
133      * @return true if the messages could be imported; false otherwise.
134      */

135     private boolean importMessageReferences(TreeView treeView,
136             MessageReferencesTransfer transferable) {
137         boolean dataWasImported = false;
138
139         IMailbox destFolder = null;
140
141         if (transferable.isDragOperation())
142             destFolder = (IMailbox) treeView.getDropTargetFolder();
143         else if (transferable.isClipboardOperation())
144             destFolder = (IMailbox) ((MailFrameMediator) frameMediator)
145                     .getTableSelection().getSourceFolder();
146
147         IMailFolderCommandReference result = transferable.getFolderReferences();
148         result.setDestinationFolder(destFolder);
149
150         if (transferable.getAction() == TransferHandler.MOVE) {
151             // move
152
MoveMessageCommand command = new MoveMessageCommand(result);
153             CommandProcessor.getInstance().addOp(command);
154         } else if (transferable.getAction() == TransferHandler.COPY) {
155             // copy
156
CopyMessageCommand command = new CopyMessageCommand(result);
157             CommandProcessor.getInstance().addOp(command);
158         }
159
160         /*
161          * // copy CopyMessageCommand command = new CopyMessageCommand(result);
162          * CommandProcessor.getInstance().addOp(command);
163          */

164         dataWasImported = true;
165
166         return dataWasImported;
167     }
168
169     /** {@inheritDoc} */
170     protected void exportDone(JComponent JavaDoc source, Transferable JavaDoc data, int action) {
171         if (source instanceof TreeView) {
172             TreeView treeView = (TreeView) source;
173
174             if (data instanceof FolderTransfer) {
175                 IMailbox draggedFolder = ((FolderTransfer) data)
176                         .getFolderReference();
177                 exportFolder(treeView, draggedFolder);
178             }
179         }
180     }
181
182     /**
183      * Export the folder. Since there is only Virtual Folders who can be copied,
184      * then all other actions are MOVE.
185      *
186      * @param treeView
187      * the treeview that has dragged folder
188      * @param folder
189      * the folder to move.
190      */

191     private void exportFolder(TreeView treeView, IMailbox folder) {
192         MailFolderCommandReference commandRef = new MailFolderCommandReference(
193                 folder);
194         IMailFolder destFolder = (IMailFolder) treeView.getDropTargetFolder();
195
196         if (folder.equals(destFolder))
197             return;
198
199         commandRef.setDestinationFolder(destFolder);
200         treeView.resetDropTargetFolder();
201
202         CommandProcessor.getInstance().addOp(new MoveFolderCommand(commandRef));
203     }
204
205     /** {@inheritDoc} */
206     public int getSourceActions(JComponent JavaDoc c) {
207         int action = TransferHandler.NONE;
208
209         if (c instanceof TreeView) {
210             action = TransferHandler.MOVE;
211         }
212
213         return action;
214     }
215
216     /** {@inheritDoc} */
217     protected Transferable JavaDoc createTransferable(JComponent JavaDoc c) {
218         Transferable JavaDoc exportObject = null;
219
220         if (c instanceof TreeView) {
221             TreeView treeView = (TreeView) c;
222             TreePath JavaDoc path = treeView.getSelectionModel().getSelectionPath();
223
224             IMailFolder folderNode = (IMailFolder) path.getLastPathComponent();
225
226             if (folderNode.supportsMove()) {
227                 exportObject = new FolderTransfer((IMailbox) folderNode);
228             }
229         }
230
231         return exportObject;
232     }
233
234     /** {@inheritDoc} */
235     public boolean canImport(JComponent JavaDoc comp, DataFlavor JavaDoc[] transferFlavors) {
236         boolean canHandleOneOfDataFlavors = false;
237
238         if (comp instanceof TreeView) {
239             TreeView treeView = (TreeView) comp;
240
241             IMailFolder dropTarget = treeView.getDropTargetFolder();
242
243             if (dropTarget != null) {
244                 for (int k = 0; (k < transferFlavors.length)
245                         && (!canHandleOneOfDataFlavors); k++) {
246                     if (transferFlavors[k]
247                             .equals(MessageReferencesTransfer.FLAVOR)) {
248                         canHandleOneOfDataFlavors = canHandleMessageImport(
249                                 treeView, dropTarget);
250                     } else if (transferFlavors[k].equals(FolderTransfer.FLAVOR)) {
251                         canHandleOneOfDataFlavors = canHandleFolderImport(
252                                 treeView, dropTarget);
253                     }
254                 }
255             }
256         }
257
258         return canHandleOneOfDataFlavors;
259     }
260
261     /**
262      * Returns true if the dragged folder can be imported to the dropped folder.
263      *
264      * @param treeView
265      * the treeview containing the drag/drop folders.
266      * @param dropTarget
267      * the folder node that is intended for the drop action.
268      * @return true if the dragged folder can be imported to the dropped folder.
269      */

270     private boolean canHandleFolderImport(TreeView treeView,
271             IMailFolder dropTarget) {
272         boolean canImport = false;
273
274         DefaultMutableTreeNode JavaDoc dragTarget = treeView
275                 .getSelectedNodeBeforeDragAction();
276
277         if ((dragTarget != null)
278                 && (!dragTarget
279                         .isNodeDescendant((DefaultMutableTreeNode JavaDoc) dropTarget))
280                 && (dragTarget != dropTarget)) {
281             canImport = dropTarget.supportsAddFolder(((IMailFolder) dragTarget)
282                     .getType());
283         }
284
285         return canImport;
286     }
287
288     /**
289      * Returns true if the dragged messages can be imported to the dropped
290      * folder.
291      *
292      * @param treeView
293      * the treeview containing the drop folder.
294      * @param dropTarget
295      * the folder node that is intended for the drop action.
296      * @return true if the dragged messages can be imported to the dropped
297      * folder.
298      */

299     private boolean canHandleMessageImport(TreeView treeView,
300             IMailFolder dropTarget) {
301         boolean canImport = false;
302
303         IMailFolder dragTarget = (IMailFolder) treeView
304                 .getSelectedNodeBeforeDragAction();
305
306         if (dragTarget != dropTarget) {
307             canImport = dropTarget.supportsAddMessage();
308         }
309
310         return canImport;
311     }
312 }
Popular Tags