mirror of
https://github.com/igniterealtime/Spark.git
synced 2025-12-01 12:27:58 +00:00
1c983396a6
git-svn-id: http://svn.igniterealtime.org/svn/repos/spark/trunk@5403 b35dd754-fafc-0310-a699-88a17e54d16e
765 lines
29 KiB
Java
765 lines
29 KiB
Java
/**
|
|
* $Revision: $
|
|
* $Date: $
|
|
*
|
|
* Copyright (C) 2006 Jive Software. All rights reserved.
|
|
*
|
|
* This software is published under the terms of the GNU Lesser Public License (LGPL),
|
|
* a copy of which is included in this distribution.
|
|
*/
|
|
|
|
package org.jivesoftware.spark.filetransfer;
|
|
|
|
import org.jivesoftware.MainWindow;
|
|
import org.jivesoftware.Spark;
|
|
import org.jivesoftware.resource.Res;
|
|
import org.jivesoftware.resource.SparkRes;
|
|
import org.jivesoftware.smack.PacketListener;
|
|
import org.jivesoftware.smack.Roster;
|
|
import org.jivesoftware.smack.XMPPException;
|
|
import org.jivesoftware.smack.filter.AndFilter;
|
|
import org.jivesoftware.smack.filter.FromContainsFilter;
|
|
import org.jivesoftware.smack.filter.PacketTypeFilter;
|
|
import org.jivesoftware.smack.packet.Message;
|
|
import org.jivesoftware.smack.packet.Packet;
|
|
import org.jivesoftware.smack.packet.Presence;
|
|
import org.jivesoftware.smack.util.StringUtils;
|
|
import org.jivesoftware.smackx.filetransfer.FileTransferManager;
|
|
import org.jivesoftware.smackx.filetransfer.FileTransferRequest;
|
|
import org.jivesoftware.smackx.filetransfer.OutgoingFileTransfer;
|
|
import org.jivesoftware.spark.ChatManager;
|
|
import org.jivesoftware.spark.SparkManager;
|
|
import org.jivesoftware.spark.component.RolloverButton;
|
|
import org.jivesoftware.spark.filetransfer.preferences.FileTransferPreference;
|
|
import org.jivesoftware.spark.preference.PreferenceManager;
|
|
import org.jivesoftware.spark.ui.ChatFrame;
|
|
import org.jivesoftware.spark.ui.ChatInputEditor;
|
|
import org.jivesoftware.spark.ui.ChatRoom;
|
|
import org.jivesoftware.spark.ui.ChatRoomButton;
|
|
import org.jivesoftware.spark.ui.ChatRoomClosingListener;
|
|
import org.jivesoftware.spark.ui.ChatRoomListenerAdapter;
|
|
import org.jivesoftware.spark.ui.ContactItem;
|
|
import org.jivesoftware.spark.ui.ContactList;
|
|
import org.jivesoftware.spark.ui.FileDropListener;
|
|
import org.jivesoftware.spark.ui.ImageSelectionPanel;
|
|
import org.jivesoftware.spark.ui.TranscriptWindow;
|
|
import org.jivesoftware.spark.ui.rooms.ChatRoomImpl;
|
|
import org.jivesoftware.spark.ui.status.StatusBar;
|
|
import org.jivesoftware.spark.util.GraphicUtils;
|
|
import org.jivesoftware.spark.util.ResourceUtils;
|
|
import org.jivesoftware.spark.util.SwingWorker;
|
|
import org.jivesoftware.spark.util.WindowsFileSystemView;
|
|
import org.jivesoftware.spark.util.log.Log;
|
|
import org.jivesoftware.sparkimpl.plugin.filetransfer.transfer.Downloads;
|
|
import org.jivesoftware.sparkimpl.plugin.filetransfer.transfer.ui.ReceiveMessage;
|
|
import org.jivesoftware.sparkimpl.plugin.filetransfer.transfer.ui.SendMessage;
|
|
import org.jivesoftware.sparkimpl.plugin.manager.Enterprise;
|
|
|
|
import javax.imageio.ImageIO;
|
|
import javax.swing.AbstractAction;
|
|
import javax.swing.JComponent;
|
|
import javax.swing.JFileChooser;
|
|
import javax.swing.JFrame;
|
|
import javax.swing.JMenu;
|
|
import javax.swing.JMenuItem;
|
|
import javax.swing.JPanel;
|
|
import javax.swing.KeyStroke;
|
|
import javax.swing.SwingUtilities;
|
|
import javax.swing.text.BadLocationException;
|
|
import javax.swing.text.Document;
|
|
import javax.swing.text.Style;
|
|
import javax.swing.text.StyleConstants;
|
|
import javax.swing.text.StyledDocument;
|
|
|
|
import java.awt.Component;
|
|
import java.awt.Cursor;
|
|
import java.awt.GraphicsDevice;
|
|
import java.awt.GraphicsEnvironment;
|
|
import java.awt.Image;
|
|
import java.awt.Rectangle;
|
|
import java.awt.Robot;
|
|
import java.awt.Toolkit;
|
|
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.awt.event.KeyAdapter;
|
|
import java.awt.event.KeyEvent;
|
|
import java.awt.event.MouseAdapter;
|
|
import java.awt.event.MouseEvent;
|
|
import java.awt.image.BufferedImage;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* Responsible for the handling of File Transfer within Spark. You would use the SparkManager
|
|
* for sending of images, files, multiple files and adding your own transfer listeners for plugin work.
|
|
*
|
|
* @author Derek DeMoro
|
|
*/
|
|
public class SparkTransferManager {
|
|
|
|
private List listeners = new ArrayList();
|
|
private File defaultDirectory;
|
|
|
|
private static SparkTransferManager singleton;
|
|
private static final Object LOCK = new Object();
|
|
private JFileChooser fc;
|
|
private FileTransferManager transferManager;
|
|
private Map waitMap = new HashMap();
|
|
|
|
/**
|
|
* Returns the singleton instance of <CODE>SparkTransferManager</CODE>,
|
|
* creating it if necessary.
|
|
* <p/>
|
|
*
|
|
* @return the singleton instance of <Code>SparkTransferManager</CODE>
|
|
*/
|
|
public static SparkTransferManager getInstance() {
|
|
// Synchronize on LOCK to ensure that we don't end up creating
|
|
// two singletons.
|
|
synchronized (LOCK) {
|
|
if (null == singleton) {
|
|
SparkTransferManager controller = new SparkTransferManager();
|
|
singleton = controller;
|
|
return controller;
|
|
}
|
|
}
|
|
return singleton;
|
|
}
|
|
|
|
private SparkTransferManager() {
|
|
boolean enabled = Enterprise.containsFeature(Enterprise.FILE_TRANSFER_FEATURE);
|
|
if (!enabled) {
|
|
return;
|
|
}
|
|
|
|
// Register Preferences
|
|
PreferenceManager prefManager = SparkManager.getPreferenceManager();
|
|
prefManager.addPreference(new FileTransferPreference());
|
|
|
|
final JMenu actionsMenu = SparkManager.getMainWindow().getMenuByName(Res.getString("menuitem.actions"));
|
|
JMenuItem downloadsMenu = new JMenuItem("", SparkRes.getImageIcon(SparkRes.DOWNLOAD_16x16));
|
|
ResourceUtils.resButton(downloadsMenu, Res.getString("menuitem.view.downloads"));
|
|
actionsMenu.add(downloadsMenu);
|
|
downloadsMenu.addActionListener(new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
Downloads downloads = Downloads.getInstance();
|
|
downloads.showDownloadsDirectory();
|
|
}
|
|
});
|
|
|
|
// Create the file transfer manager
|
|
transferManager = new FileTransferManager(SparkManager.getConnection());
|
|
final ContactList contactList = SparkManager.getWorkspace().getContactList();
|
|
|
|
// Create the listener
|
|
transferManager.addFileTransferListener(new org.jivesoftware.smackx.filetransfer.FileTransferListener() {
|
|
public void fileTransferRequest(final FileTransferRequest request) {
|
|
SwingUtilities.invokeLater(new Runnable() {
|
|
public void run() {
|
|
handleTransferRequest(request, contactList);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
// Add Send File to Chat Room
|
|
addSendFileButton();
|
|
|
|
|
|
contactList.addFileDropListener(new FileDropListener() {
|
|
public void filesDropped(Collection files, Component component) {
|
|
if (component instanceof ContactItem) {
|
|
ContactItem item = (ContactItem)component;
|
|
|
|
ChatRoom chatRoom = null;
|
|
Iterator iter = files.iterator();
|
|
while (iter.hasNext()) {
|
|
chatRoom = sendFile((File)iter.next(), item.getFullJID());
|
|
}
|
|
|
|
if (chatRoom != null) {
|
|
SparkManager.getChatManager().getChatContainer().activateChatRoom(chatRoom);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
if (defaultDirectory == null) {
|
|
defaultDirectory = new File(System.getProperty("user.home"));
|
|
}
|
|
|
|
addPresenceListener();
|
|
|
|
// Add View Downloads to Command Panel
|
|
StatusBar statusBar = SparkManager.getWorkspace().getStatusBar();
|
|
JPanel commandPanel = statusBar.getCommandPanel();
|
|
|
|
RolloverButton viewDownloads = new RolloverButton(SparkRes.getImageIcon(SparkRes.DOWNLOAD_16x16));
|
|
viewDownloads.setToolTipText(Res.getString("menuitem.view.downloads"));
|
|
commandPanel.add(viewDownloads);
|
|
viewDownloads.addActionListener(new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
Downloads downloads = Downloads.getInstance();
|
|
downloads.showDownloadsDirectory();
|
|
}
|
|
});
|
|
}
|
|
|
|
private void handleTransferRequest(FileTransferRequest request, ContactList contactList) {
|
|
// Check if a listener handled this request
|
|
if (fireTransferListeners(request)) {
|
|
return;
|
|
}
|
|
|
|
String requestor = request.getRequestor();
|
|
String bareJID = StringUtils.parseBareAddress(requestor);
|
|
|
|
|
|
ContactItem contactItem = contactList.getContactItemByJID(bareJID);
|
|
|
|
ChatRoom chatRoom;
|
|
if (contactItem != null) {
|
|
chatRoom = SparkManager.getChatManager().createChatRoom(bareJID, contactItem.getNickname(), contactItem.getNickname());
|
|
}
|
|
else {
|
|
chatRoom = SparkManager.getChatManager().createChatRoom(bareJID, bareJID, bareJID);
|
|
}
|
|
|
|
TranscriptWindow transcriptWindow = chatRoom.getTranscriptWindow();
|
|
StyledDocument doc = (StyledDocument)transcriptWindow.getDocument();
|
|
|
|
// The image must first be wrapped in a style
|
|
Style style = doc.addStyle("StyleName", null);
|
|
|
|
final ReceiveMessage receivingMessageUI = new ReceiveMessage();
|
|
receivingMessageUI.acceptFileTransfer(request);
|
|
|
|
chatRoom.addClosingListener(new ChatRoomClosingListener() {
|
|
public void closing() {
|
|
receivingMessageUI.cancelTransfer();
|
|
}
|
|
});
|
|
|
|
StyleConstants.setComponent(style, receivingMessageUI);
|
|
|
|
// Insert the image at the end of the text
|
|
try {
|
|
doc.insertString(doc.getLength(), "ignored text", style);
|
|
doc.insertString(doc.getLength(), "\n", null);
|
|
}
|
|
catch (BadLocationException e) {
|
|
Log.error(e);
|
|
}
|
|
|
|
chatRoom.scrollToBottom();
|
|
|
|
SparkManager.getChatManager().getChatContainer().fireNotifyOnMessage(chatRoom);
|
|
}
|
|
|
|
|
|
public void sendFileTo(ContactItem item) {
|
|
final ContactList contactList = SparkManager.getWorkspace().getContactList();
|
|
getFileChooser().setDialogTitle(Res.getString("title.select.file.to.send"));
|
|
int ok = getFileChooser().showOpenDialog(contactList);
|
|
if (ok != JFileChooser.APPROVE_OPTION) {
|
|
return;
|
|
}
|
|
|
|
File[] files = getFileChooser().getSelectedFiles();
|
|
for (int i = 0; i < files.length; i++) {
|
|
File file = files[i];
|
|
if (file.exists()) {
|
|
defaultDirectory = file.getParentFile();
|
|
sendFile(file, item.getFullJID());
|
|
}
|
|
}
|
|
}
|
|
|
|
private void addSendFileButton() {
|
|
final ChatManager chatManager = SparkManager.getChatManager();
|
|
chatManager.addChatRoomListener(new ChatRoomListenerAdapter() {
|
|
|
|
FileDropListener fileDropListener;
|
|
|
|
public void chatRoomOpened(final ChatRoom room) {
|
|
if (!(room instanceof ChatRoomImpl)) {
|
|
return;
|
|
}
|
|
|
|
|
|
final ChatInputEditor chatSendField = room.getChatInputEditor();
|
|
chatSendField.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("Ctrl v"), "paste");
|
|
|
|
chatSendField.getActionMap().put("paste", new AbstractAction("paste") {
|
|
public void actionPerformed(ActionEvent evt) {
|
|
String clipboardText = SparkManager.getClipboard();
|
|
|
|
if (clipboardText == null && getClipboard() != null) {
|
|
sendImage(getClipboard(), room);
|
|
}
|
|
else {
|
|
try {
|
|
Document document = chatSendField.getDocument();
|
|
document.insertString(chatSendField.getCaretPosition(), clipboardText, null);
|
|
}
|
|
catch (BadLocationException e) {
|
|
Log.error(e);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
|
|
fileDropListener = new FileDropListener() {
|
|
public void filesDropped(Collection files, Component component) {
|
|
if (component instanceof ChatRoomImpl) {
|
|
ChatRoomImpl roomImpl = (ChatRoomImpl)component;
|
|
|
|
|
|
Iterator iter = files.iterator();
|
|
while (iter.hasNext()) {
|
|
sendFile((File)iter.next(), roomImpl.getParticipantJID());
|
|
}
|
|
|
|
SparkManager.getChatManager().getChatContainer().activateChatRoom(roomImpl);
|
|
}
|
|
}
|
|
};
|
|
|
|
room.addFileDropListener(fileDropListener);
|
|
|
|
|
|
ChatRoomButton sendFileButton = new ChatRoomButton("", SparkRes.getImageIcon(SparkRes.SEND_FILE_24x24));
|
|
sendFileButton.setToolTipText(Res.getString("message.send.file.to.user"));
|
|
|
|
room.getToolBar().addChatRoomButton(sendFileButton);
|
|
|
|
final ChatRoomButton sendScreenShotButton = new ChatRoomButton("", SparkRes.getImageIcon(SparkRes.PHOTO_IMAGE));
|
|
sendScreenShotButton.setToolTipText(Res.getString("message.send.picture"));
|
|
room.getToolBar().addChatRoomButton(sendScreenShotButton);
|
|
|
|
sendScreenShotButton.addActionListener(new ActionListener() {
|
|
public void actionPerformed(ActionEvent actionEvent) {
|
|
sendScreenshot(sendScreenShotButton, room);
|
|
}
|
|
});
|
|
|
|
sendFileButton.addActionListener(new ActionListener() {
|
|
public void actionPerformed(ActionEvent e) {
|
|
SwingWorker worker = new SwingWorker() {
|
|
public Object construct() {
|
|
try {
|
|
Thread.sleep(10);
|
|
}
|
|
catch (InterruptedException e1) {
|
|
Log.error(e1);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void finished() {
|
|
ChatRoomImpl roomImpl = (ChatRoomImpl)room;
|
|
|
|
getFileChooser().setDialogTitle(Res.getString("title.select.file.to.send"));
|
|
getFileChooser().setMultiSelectionEnabled(true);
|
|
int ok = getFileChooser().showOpenDialog(roomImpl);
|
|
if (ok != JFileChooser.APPROVE_OPTION) {
|
|
return;
|
|
}
|
|
|
|
File[] file = getFileChooser().getSelectedFiles();
|
|
if (file == null || file.length == 0) {
|
|
return;
|
|
}
|
|
|
|
|
|
final int no = file.length;
|
|
for (int i = 0; i < no; i++) {
|
|
File sendFile = file[i];
|
|
|
|
if (sendFile.exists()) {
|
|
defaultDirectory = sendFile.getParentFile();
|
|
sendFile(sendFile, roomImpl.getParticipantJID());
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
};
|
|
worker.start();
|
|
}
|
|
});
|
|
}
|
|
|
|
public void chatRoomClosed(ChatRoom room) {
|
|
room.removeFileDropListener(fileDropListener);
|
|
}
|
|
});
|
|
|
|
|
|
}
|
|
|
|
private void sendScreenshot(final ChatRoomButton button, final ChatRoom room) {
|
|
button.setEnabled(false);
|
|
|
|
final MainWindow mainWindow = SparkManager.getMainWindow();
|
|
final ChatFrame chatFrame = SparkManager.getChatManager().getChatContainer().getChatFrame();
|
|
|
|
final boolean mainWindowVisible = mainWindow.isVisible();
|
|
final boolean chatFrameVisible = chatFrame.isVisible();
|
|
|
|
if (mainWindowVisible) {
|
|
mainWindow.setVisible(false);
|
|
}
|
|
|
|
if (chatFrameVisible) {
|
|
chatFrame.setVisible(false);
|
|
}
|
|
|
|
final SwingWorker worker = new SwingWorker() {
|
|
public Object construct() {
|
|
try {
|
|
Thread.sleep(1000);
|
|
final Robot robot = new Robot();
|
|
Rectangle area = new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());
|
|
return robot.createScreenCapture(area);
|
|
}
|
|
catch (Exception e) {
|
|
Log.error(e);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void finished() {
|
|
final JFrame frame = new JFrame();
|
|
frame.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
|
|
|
|
final BufferedImage bufferedImage = (BufferedImage)get();
|
|
final ImageSelectionPanel mainPanel = new ImageSelectionPanel(bufferedImage);
|
|
mainPanel.addMouseListener(new MouseAdapter() {
|
|
public void mouseReleased(MouseEvent e) {
|
|
Rectangle clip = mainPanel.getClip();
|
|
BufferedImage newImage = null;
|
|
try {
|
|
newImage = bufferedImage.getSubimage((int)clip.getX(), (int)clip.getY(), (int)clip.getWidth(), (int)clip.getHeight());
|
|
}
|
|
catch (Exception e1) {
|
|
|
|
}
|
|
|
|
|
|
if (newImage != null) {
|
|
sendImage(newImage, room);
|
|
}
|
|
|
|
frame.dispose();
|
|
frame.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
|
|
|
|
if (mainWindowVisible) {
|
|
mainWindow.setVisible(false);
|
|
}
|
|
|
|
if (chatFrameVisible) {
|
|
chatFrame.setVisible(false);
|
|
}
|
|
|
|
}
|
|
});
|
|
|
|
frame.addKeyListener(new KeyAdapter() {
|
|
public void keyTyped(KeyEvent e) {
|
|
if (e.getKeyChar() == KeyEvent.VK_ESCAPE) {
|
|
frame.dispose();
|
|
frame.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
|
|
if (mainWindowVisible) {
|
|
mainWindow.setVisible(false);
|
|
}
|
|
|
|
if (chatFrameVisible) {
|
|
chatFrame.setVisible(false);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
|
|
if (bufferedImage != null) {
|
|
|
|
frame.setUndecorated(true);
|
|
frame.setSize(bufferedImage.getWidth(null), bufferedImage.getHeight());
|
|
frame.getContentPane().add(mainPanel);
|
|
|
|
// Determine if full-screen mode is supported directly
|
|
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
|
|
GraphicsDevice gs = ge.getDefaultScreenDevice();
|
|
if (gs.isFullScreenSupported()) {
|
|
|
|
gs.setFullScreenWindow(frame);
|
|
}
|
|
else {
|
|
// Full-screen mode will be simulated
|
|
}
|
|
}
|
|
|
|
|
|
button.setEnabled(true);
|
|
}
|
|
};
|
|
worker.start();
|
|
}
|
|
|
|
private void addPresenceListener() {
|
|
SparkManager.getConnection().addPacketListener(new PacketListener() {
|
|
public void processPacket(Packet packet) {
|
|
Presence presence = (Presence)packet;
|
|
if (presence != null) {
|
|
String bareJID = StringUtils.parseBareAddress(presence.getFrom());
|
|
|
|
// Iterate through map.
|
|
List list = (List)waitMap.get(bareJID);
|
|
if (list != null) {
|
|
// Iterate through list and send.
|
|
Iterator iter = list.iterator();
|
|
ChatRoom room = null;
|
|
while (iter.hasNext()) {
|
|
File file = (File)iter.next();
|
|
room = sendFile(file, bareJID);
|
|
}
|
|
|
|
if (room != null) {
|
|
Message message = new Message();
|
|
message.setBody(Res.getString("message.sent.offline.files"));
|
|
room.sendMessage(message);
|
|
}
|
|
}
|
|
|
|
|
|
waitMap.remove(bareJID);
|
|
}
|
|
}
|
|
}, new PacketTypeFilter(Presence.class));
|
|
}
|
|
|
|
/**
|
|
* Send a file to a user.
|
|
*
|
|
* @param file the file to send.
|
|
* @param bJID the bare jid of the user to send the file to.
|
|
* @return the ChatRoom of the user.
|
|
*/
|
|
public ChatRoom sendFile(File file, String bJID) {
|
|
Roster roster = SparkManager.getConnection().getRoster();
|
|
Presence presence = roster.getPresence(bJID);
|
|
|
|
final ContactList contactList = SparkManager.getWorkspace().getContactList();
|
|
|
|
if (presence == null) {
|
|
List list = (List)waitMap.get(bJID);
|
|
if (list == null) {
|
|
list = new ArrayList();
|
|
}
|
|
|
|
list.add(file);
|
|
waitMap.put(bJID, list);
|
|
|
|
ChatRoom chatRoom;
|
|
ContactItem contactItem = contactList.getContactItemByJID(bJID);
|
|
if (contactItem != null) {
|
|
chatRoom = SparkManager.getChatManager().createChatRoom(bJID, contactItem.getNickname(), contactItem.getNickname());
|
|
}
|
|
else {
|
|
chatRoom = SparkManager.getChatManager().createChatRoom(bJID, bJID, bJID);
|
|
}
|
|
|
|
chatRoom.getTranscriptWindow().insertErrorMessage("The user is offline. Will auto-send \"" + file.getName() + "\" when user comes back online.");
|
|
return null;
|
|
}
|
|
|
|
|
|
String bareJID = StringUtils.parseBareAddress(presence.getFrom());
|
|
|
|
// Create the outgoing file transfer
|
|
final OutgoingFileTransfer transfer = transferManager.createOutgoingFileTransfer(presence.getFrom());
|
|
|
|
ContactItem contactItem = contactList.getContactItemByJID(bareJID);
|
|
|
|
ChatRoom chatRoom;
|
|
if (contactItem != null) {
|
|
chatRoom = SparkManager.getChatManager().createChatRoom(bareJID, contactItem.getNickname(), contactItem.getNickname());
|
|
}
|
|
else {
|
|
chatRoom = SparkManager.getChatManager().createChatRoom(bareJID, bareJID, bareJID);
|
|
}
|
|
|
|
|
|
TranscriptWindow transcriptWindow = chatRoom.getTranscriptWindow();
|
|
StyledDocument doc = (StyledDocument)transcriptWindow.getDocument();
|
|
|
|
// The image must first be wrapped in a style
|
|
Style style = doc.addStyle("StyleName", null);
|
|
|
|
SendMessage sendingUI = new SendMessage();
|
|
try {
|
|
transfer.sendFile(file, "Sending file");
|
|
}
|
|
catch (XMPPException e) {
|
|
Log.error(e);
|
|
}
|
|
|
|
// Add listener to cancel transfer is sending file to user who just went offline.
|
|
AndFilter presenceFilter = new AndFilter(new PacketTypeFilter(Presence.class), new FromContainsFilter(bareJID));
|
|
final PacketListener packetListener = new PacketListener() {
|
|
public void processPacket(Packet packet) {
|
|
Presence presence = (Presence)packet;
|
|
if (presence == null || presence.getType() == Presence.Type.unavailable) {
|
|
if (transfer != null) {
|
|
transfer.cancel();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// Add presence listener to check if user is offline and cancel sending.
|
|
SparkManager.getConnection().addPacketListener(packetListener, presenceFilter);
|
|
|
|
chatRoom.addClosingListener(new ChatRoomClosingListener() {
|
|
public void closing() {
|
|
SparkManager.getConnection().removePacketListener(packetListener);
|
|
|
|
if (!transfer.isDone()) {
|
|
transfer.cancel();
|
|
}
|
|
}
|
|
});
|
|
|
|
sendingUI.sendFile(transfer, transferManager, presence.getFrom(), contactItem.getNickname());
|
|
StyleConstants.setComponent(style, sendingUI);
|
|
|
|
// Insert the image at the end of the text
|
|
try {
|
|
doc.insertString(doc.getLength(), "ignored text", style);
|
|
doc.insertString(doc.getLength(), "\n", null);
|
|
}
|
|
catch (BadLocationException e) {
|
|
Log.error(e);
|
|
}
|
|
|
|
chatRoom.scrollToBottom();
|
|
return chatRoom;
|
|
}
|
|
|
|
/**
|
|
* Send an image to a user.
|
|
*
|
|
* @param image the image to send.
|
|
* @param room the ChatRoom of the user you wish to send the image to.
|
|
*/
|
|
public void sendImage(final Image image, final ChatRoom room) {
|
|
File tmpDirectory = new File(Spark.getUserHome(), "Spark/tempImages");
|
|
tmpDirectory.mkdirs();
|
|
|
|
String imageName = "image_" + StringUtils.randomString(2) + ".png";
|
|
final File imageFile = new File(tmpDirectory, imageName);
|
|
// Write image to system.
|
|
|
|
room.setCursor(new Cursor(Cursor.WAIT_CURSOR));
|
|
|
|
SwingWorker worker = new SwingWorker() {
|
|
public Object construct() {
|
|
try {
|
|
// Write out file in separate thread.
|
|
BufferedImage bi = GraphicUtils.convert(image);
|
|
ImageIO.write(bi, "png", imageFile);
|
|
}
|
|
catch (InterruptedException e) {
|
|
Log.error(e);
|
|
}
|
|
catch (IOException e) {
|
|
Log.error(e);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void finished() {
|
|
ChatRoomImpl roomImpl = (ChatRoomImpl)room;
|
|
sendFile(imageFile, roomImpl.getParticipantJID());
|
|
SparkManager.getChatManager().getChatContainer().activateChatRoom(room);
|
|
room.setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
|
|
}
|
|
};
|
|
worker.start();
|
|
}
|
|
|
|
/**
|
|
* Returns an image if one is found in the clipboard, otherwise null is returned.
|
|
*
|
|
* @return the image in the clipboard if found, otherwise null.
|
|
*/
|
|
public static Image getClipboard() {
|
|
Transferable t = Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null);
|
|
|
|
try {
|
|
if (t != null && t.isDataFlavorSupported(DataFlavor.imageFlavor)) {
|
|
return (Image)t.getTransferData(DataFlavor.imageFlavor);
|
|
}
|
|
}
|
|
catch (UnsupportedFlavorException e) {
|
|
}
|
|
catch (IOException e) {
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Adds a new TransferListener to the SparkManager. FileTransferListeners can be used
|
|
* to intercept incoming file transfers for own customizations. You may wish to not
|
|
* allow certain file transfers, or have your own UI to handle incoming files.
|
|
*
|
|
* @param listener the listener
|
|
*/
|
|
public void addTransferListener(FileTransferListener listener) {
|
|
listeners.add(listener);
|
|
}
|
|
|
|
/**
|
|
* Removes the FileTransferListener.
|
|
*
|
|
* @param listener the listener
|
|
*/
|
|
public void removeTransferListener(FileTransferListener listener) {
|
|
listeners.remove(listener);
|
|
}
|
|
|
|
private boolean fireTransferListeners(FileTransferRequest request) {
|
|
final Iterator iter = new ArrayList(listeners).iterator();
|
|
while (iter.hasNext()) {
|
|
FileTransferListener listener = (FileTransferListener)iter.next();
|
|
boolean accepted = listener.handleTransfer(request);
|
|
if (accepted) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private JFileChooser getFileChooser() {
|
|
if (fc == null) {
|
|
fc = new JFileChooser(defaultDirectory);
|
|
fc.setMultiSelectionEnabled(true);
|
|
if (Spark.isWindows()) {
|
|
fc.setFileSystemView(new WindowsFileSystemView());
|
|
}
|
|
}
|
|
return fc;
|
|
}
|
|
}
|