/*
* Copyright 2000-2006 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package jetbrains.communicator.idea.toolWindow;
import jetbrains.communicator.commands.SendMessageCommand;
import jetbrains.communicator.core.Pico;
import jetbrains.communicator.core.users.User;
import jetbrains.communicator.core.users.UserModel;
import jetbrains.communicator.idea.actions.BaseAction;
import jetbrains.communicator.util.TreeUtils;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.Nullable;
import javax.swing.*;
import javax.swing.tree.TreePath;
import java.awt.*;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;
/**
* @author Kir
*/
public class UserTreeTransferHandler extends TransferHandler {
private static final Logger LOG = Logger.getLogger(UserTreeTransferHandler.class);
public static final Pattern EXCEPTION_PATTERN = Pattern.compile("\\s+at ");
private final UserModel myUserModel;
public UserTreeTransferHandler(UserModel userModel) {
myUserModel = userModel;
}
protected Transferable createTransferable(JComponent c) {
return new UsersTransferable(getTree(c));
}
public int getSourceActions(JComponent c) {
return MOVE;
}
public boolean canImport(JComponent comp, DataFlavor[] transferFlavors) {
List<DataFlavor> flavors = Arrays.asList(transferFlavors);
return flavors.contains(UsersTransferable.getMyDataFlavor()) || (flavors.contains(DataFlavor.stringFlavor));
}
public boolean importData(JComponent comp, Transferable t) {
if (canImport(comp, t.getTransferDataFlavors())) {
try {
if (Arrays.asList(t.getTransferDataFlavors()).contains(UsersTransferable.getMyDataFlavor())) {
processUsersImport(comp, t);
return true;
}
else { // import text
String text = t.getTransferData(DataFlavor.stringFlavor).toString();
return processTextImport(text, comp);
}
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
}
return false;
}
private static boolean processTextImport(String text, Component c) {
SendMessageCommand command =
Pico.getCommandManager().getCommand(SendMessageCommand.class, BaseAction.getContainer(c));
command.setMessage(text);
if (command.isEnabled()) {
command.execute();
return true;
}
return false;
}
private void processUsersImport(JComponent comp, Transferable t) throws UnsupportedFlavorException, IOException {
final String targetGroup = getTargetGroup(comp);
final User[] movedUsers = (User[]) t.getTransferData(UsersTransferable.getMyDataFlavor());
for (User movedUser : movedUsers) {
movedUser.setGroup(targetGroup, myUserModel);
}
}
private static String getTargetGroup(JComponent comp) {
final Object userObject = getUserObject(comp);
String group = userObject != null ? userObject.toString() : UserModel.DEFAULT_GROUP;
if (userObject instanceof User) {
User user = (User) userObject;
group = user.getGroup();
}
return group;
}
@Nullable
private static Object getUserObject(JComponent comp) {
final TreePath path = getTree(comp).getSelectionPath();
return path != null ? TreeUtils.getUserObject(path) : null;
}
private static JTree getTree(JComponent c) {
return ((JTree) c);
}
public static class UsersTransferable implements Transferable {
private final List<User> myUsers = new ArrayList<User>();
private static DataFlavor ourDataFlavor;
public UsersTransferable(JTree tree) {
final TreePath[] selectionPaths = tree.getSelectionPaths();
if (selectionPaths != null) {
for (TreePath path : selectionPaths) {
final Object userObject = TreeUtils.getUserObject(path.getLastPathComponent());
if (userObject instanceof User) {
myUsers.add((User)userObject);
}
}
}
}
public DataFlavor[] getTransferDataFlavors() {
if (myUsers.size() > 0)
return new DataFlavor[] {DataFlavor.stringFlavor, getMyDataFlavor()};
else
return new DataFlavor[0];
}
public boolean isDataFlavorSupported(DataFlavor flavor) {
return Arrays.asList(getTransferDataFlavors()).contains(flavor);
}
public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
if (flavor == getMyDataFlavor()) {
return myUsers.toArray(new User[myUsers.size()]);
}
else if (flavor == DataFlavor.stringFlavor) {
StringBuffer sb = new StringBuffer(10 * myUsers.size());
if (myUsers.size() > 0) {
sb.append((myUsers.get(0)).getDisplayName());
for (int i = 1; i < myUsers.size(); i++) {
sb.append('\n');
sb.append((myUsers.get(i)).getDisplayName());
}
}
return sb.toString();
}
throw new UnsupportedFlavorException(flavor);
}
private static DataFlavor getMyDataFlavor() {
if (ourDataFlavor != null) return ourDataFlavor;
try {
ourDataFlavor = new DataFlavor(DataFlavor.javaJVMLocalObjectMimeType + ";class=" + Map.class.getName());
return ourDataFlavor;
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
}
}