function getFieldsFromURL() {
var query = self.location.search;
if(query.length > 0) {
var str = query.substring(1);
var list = new Array();
var i = 0;
for(;;++i) {
var end = str.indexOf('=');
if(end == -1) return (i == 0)?null:list;
list[i] = unescape(str.substring(0, end));
list[list[i]] = getFieldFromURL(list[i]);
end = str.indexOf('&');
if(end == -1) return (i == 0)?null:list;
str = str.substring(end+1, str.length);
}
} else {
return null;
}
}
JavaScript
/**
* Download a Content.
* @param mapping The action mapping
* @param form The action form
* @param request The requst
* @param response The response
* @return a valid struts mapping
*/
public final ActionForward download(final ActionMapping mapping, final ActionForm form, final HttpServletRequest request, final HttpServletResponse response) {
byte[] content = request.getParameter("content");
String fileName = request.getParameter("fileName");
String fileContentType = request.getParameter("fileContentType");
String view = request.getParameter("view");
OutputStream out = null;
try {
response.setHeader("Pragma", "public");
response.setHeader("Cache-Control", "max-age=1, must-revalidate");
// This will ask the user to open or save the content (without it the browser will try to download it)
if (!"true".toLowerCase().equals(view) || StringHelper.isEmpty(doc.getFileContentType())) {
response.setHeader("Content-Disposition", "attachment; filename="+fileName);
}
response.setContentLength(content.length);
if (!StringHelper.isEmpty(fileContentType)) {
response.setContentType(fileContentType);
} else {
response.setContentType("application/octet-stream");
}
out = response.getOutputStream();
out.write(content);
} catch (Exception ex) {
logger.error(ex.getMessage(), ex);
return mapping.findForward(ERROR);
} finally {
if (out != null) {
try {
out.flush();
out.close();
} catch (Exception ex) {
logger.error(ex.getMessage(), ex);
}
}
}
return null;
}
Java
/**
* Populate the bean prefix using request parameters.
* @param request The HTTP request
* @param form ..
* @param arrayKey ..
* @param arrayItemClazz ..
*/
public static void getPotentialNewElement(final HttpServletRequest request, final Object beanForm, final String arrayKey, final Class arrayItemClazz) throws Exception {
Object array = ReflectHelper.invokeGetter(beanForm, arrayKey);
if (array.getClass().isArray()) {
int offsetIndex = Array.getLength(array);
Object newArrayElement = null;
List getters = ReflectHelper.getGettersRecursivly(arrayItemClazz);
do {
for (Iterator iter = getters.iterator(); iter.hasNext();) {
Method getter = (Method) iter.next();
if (getter.getReturnType().getName().startsWith("java.lang.String")) {
String getterKey = ReflectHelper.getFieldName(getter);
String value = request.getParameter(arrayKey + "[" + offsetIndex + "]." + getter);
if (value != null) {
if (newArrayElement == null) {
newArrayElement = ReflectHelper.newInstance(arrayItemClazz.getName());
}
ReflectHelper.invokeSetter(newArrayElement, getterKey, value, String.class);
}
}
}
if (newArrayElement != null) {
Object newArray = Array.newInstance(arrayItemClazz, offsetIndex + 1);
for (int i = 0; i < offsetIndex; ++i) {
Array.set(newArray, i, Array.get(array, i));
}
offsetIndex++;
Array.set(newArray, offsetIndex, newArrayElement);
}
} while (newArrayElement != null);
}
}
Java
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class TestMain {
public static void main(String[] args) {
// construct test object
ObjectA originalObj = new ObjectA();
testSerialization(originalObj);
}
public static void testSerialization (Object originalObj)
{
ObjectA extractedObj = null;
// serialize
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream oos;
System.out.println("Trying to serialize the object...");
try {
oos = new ObjectOutputStream(out);
oos.writeObject(originalObj);
oos.close();
System.out.println("=>> Success.");
} catch (IOException e) {
System.err.println("=>> Failure: "+e.getMessage());
e.printStackTrace();
return;
}
//deserialize
byte[] pickled = out.toByteArray();
InputStream in = new ByteArrayInputStream(pickled);
ObjectInputStream ois;
System.out.println("Trying to deserialize the object...");
try {
ois = new ObjectInputStream(in);
Object obj = ois.readObject();
extractedObj = (ObjectA) obj;
System.out.println("=>> Success.");
} catch (IOException e) {
System.err.println("=>> Failure: "+e.getMessage());
return;
} catch (ClassNotFoundException e) {
System.err.println("=>> Failure: "+e.getMessage());
e.printStackTrace();
return;
}
// test the result
System.out.println("Inuring that the extracted object is equal to the original one...");
if (!originalObj.equals(extractedObj)) {
System.err.println("=>> Failure: Objects are not equals.");
return;
} else {
System.out.println("=>> Success.");
}
}
}
Java
public static Package[] getSubPackages(Package pckg) throws IOException, ClassNotFoundException {
// Translate the package name into an absolute path
String name = "/" + pckg.getName().replace('.','/');
// Get a File object for the package
URL url = Launcher.class.getResource(name);
File directory = new File(url.getFile());
if (directory.exists()) {
// Get the list of the files contained in the package
File[] files = directory.listFiles();
ArrayList pckgs = new ArrayList();
for (int i=0; i<files.length;++i) {
// we are only interested in .class files
if (files[i].isDirectory()) {
// removes the .class extension
pckgs.add(Package.getPackage(pckg.getName()+"."+files[i].getName()));
}
}
Package[] packages = new Package[pckgs.size()];
for (int i=0; i<pckgs.size();++i) packages[i] = (Package)pckgs.get(i);
return packages;
} else {
throw new IOException("Invalid directory: "+url);
}
}
Java
// Print a debug message with the class container name and the line position
public static void debug(String message) {
try {
throw new Throwable();
} catch (Throwable th) {
StackTraceElement elmt = th.getStackTrace()[1];
System.out.println("[DEBUG] "+elmt.getClassName()+"."+elmt.getMethodName()+"("+elmt.getFileName()+":"+elmt.getLineNumber()+") # "+message);
}
}
Java
package com.pingus.dnd.transferables;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
import java.util.ArrayList;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
public class TransferableLabel extends TransferableObject {
public TransferableLabel(final JLabel label, final DataFlavor[] acceptedFlavors, final Transferable defaultTransferableObject) {
super(label, acceptedFlavors, defaultTransferableObject);
}
public TransferableLabel(final JLabel label, final ArrayList acceptedFlavors, final Transferable defaultTransferableObject) {
super(label, acceptedFlavors, defaultTransferableObject);
}
public Object getTransferData(final DataFlavor flavor) throws UnsupportedFlavorException, IOException {
if(flavor.equals(getPreferredFlavor())) {
System.out.println("[TransferableLabel] <getTransferData> returning label");
// Return JLabel
return this.getObject();
} else if(flavor.equals(DataFlavor.imageFlavor)) {
System.out.println("[TransferableLabel] <getTransferData> returning ...");
// Return Image
Icon icon = ((JLabel)this.getObject()).getIcon();
if (icon instanceof ImageIcon) {
System.out.println("[TransferableLabel] <getTransferData> Image.");
return ((ImageIcon) icon).getImage();
}
} else if(flavor.equals(DataFlavor.stringFlavor)) {
System.out.println("[TransferableLabel] <getTransferData> returning label text");
// Return label text
return ((JLabel)this.getObject()).getText();
} else if(flavor.equals(DataFlavor.getTextPlainUnicodeFlavor())) {
return TransferableObject.exportAsInputStream(((JLabel)this.getObject()).getText(), flavor);
}
System.out.println("[TransferableLabel] <getTransferData> returning nothing");
System.out.println("[TransferableLabel] <getTransferData> for flavor "+flavor);
return super.getTransferData(flavor);
}
}
Java
package com.pingus.dnd.transferables.handlers;
import java.awt.Image;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;
import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.TransferHandler;
import com.pingus.dnd.transferables.TransferableLabel;
import com.pingus.dnd.transferables.TransferableObject;
public class LabelSelection extends TransferHandler {
private static final DataFlavor[] STANDARD_FLAVORS = new DataFlavor[] {
DataFlavor.imageFlavor,
DataFlavor.stringFlavor,
DataFlavor.getTextPlainUnicodeFlavor()
};
/**
* Creates a new instance of TreeTransferHandler
*/
public LabelSelection() {
super();
}
public int getSourceActions(JComponent c) {
return TransferHandler.COPY_OR_MOVE;
}
protected Transferable createTransferable(final JComponent component) {
System.out.println("[LabelTransferHandler] <createTransferable>");
if (component instanceof JLabel) {
return new TransferableLabel((JLabel)component, STANDARD_FLAVORS, super.createTransferable(component));
/*
return new TransferableObject(component, STANDARD_FLAVORS, super.createTransferable(component)) {
public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
if(flavor.equals(getPreferredFlavor())) {
System.out.println("[LabelTransferHandler] <createTransferable> [TransferableObject] <getTransferData> returning label");
// Return JLabel
return component;
} else if(flavor.equals(DataFlavor.imageFlavor)) {
System.out.println("[LabelTransferHandler] <createTransferable> [TransferableObject] <getTransferData> returning ...");
// Return Image
Icon icon = ((JLabel)component).getIcon();
if (icon instanceof ImageIcon) {
System.out.println("[LabelTransferHandler] <createTransferable> [TransferableObject] <getTransferData> Image.");
return ((ImageIcon) icon).getImage();
}
} else if(flavor.equals(DataFlavor.stringFlavor)) {
System.out.println("[LabelTransferHandler] <createTransferable> [TransferableObject] <getTransferData> returning label text");
// Return label text
return ((JLabel)component).getText();
} else if(flavor.equals(DataFlavor.getTextPlainUnicodeFlavor())) {
return this.exportAsInputStream(((JLabel)component).getText(), flavor);
}
System.out.println("[LabelTransferHandler] <createTransferable> [TransferableObject] <getTransferData> returning nothing");
System.out.println("[LabelTransferHandler] <createTransferable> [TransferableObject] <getTransferData> for flavor "+flavor);
return super.getTransferData(flavor);
}
};
/**/
}
return new TransferableObject(component, STANDARD_FLAVORS, super.createTransferable(component));
}
public boolean importData(JComponent comp, Transferable t) {
System.out.println("[LabelTransferHandler] <inportData>");
if (comp instanceof JLabel) {
JLabel label = (JLabel) comp;
DataFlavor labelFlavor = new DataFlavor(comp.getClass(), comp.getClass().getName());
try {
if (t.isDataFlavorSupported(labelFlavor)) {
System.out.println("[LabelTransferHandler] Importing Label");
JLabel dropedObject = (JLabel) t.getTransferData(labelFlavor);
System.out.println("[LabelTransferHandler] Setting icon");
label.setIcon(dropedObject.getIcon());
System.out.println("[LabelTransferHandler] Setting text to " + dropedObject.getText());
label.setText(dropedObject.getText());
System.out.println("[LabelTransferHandler] Setting tool tip text to " + dropedObject.getToolTipText());
label.setToolTipText(dropedObject.getToolTipText());
System.out.println("[LabelTransferHandler] Repaint label");
label.repaint();
return true;
} else if (t.isDataFlavorSupported(DataFlavor.imageFlavor)) {
System.out.println("[LabelTransferHandler] Importing Image ...");
Image image = (Image) t.getTransferData(DataFlavor.imageFlavor);
ImageIcon icon = new ImageIcon(image);
label.setIcon(icon);
return true;
} else if (t.isDataFlavorSupported(DataFlavor.stringFlavor)) {
System.out.println("[LabelTransferHandler] Importing text ...");
String text = (String)t.getTransferData(DataFlavor.stringFlavor);
label.setText(text);
return true;
} else if (t.isDataFlavorSupported(DataFlavor.getTextPlainUnicodeFlavor())) {
label.setText(TransferableObject.importAsInputStream(t));
return true;
}
} catch (RuntimeException ex) {
ex.printStackTrace();
} catch (UnsupportedFlavorException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
return super.importData(comp, t);
}
public boolean canImport(JComponent comp, DataFlavor flavor[]) {
if (!(comp instanceof JLabel)) {
return false;
}
for (int i=0; i<flavor.length; ++i) {
for (int j=0; j<STANDARD_FLAVORS.length; ++j) {
if (flavor[i].equals(STANDARD_FLAVORS[j])) {
return true;
}
}
}
System.out.println("[LabelSelection] <canImport> returning false");
return false;
}
}
Java
package com.pingus.dnd.transferables;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
public class TransferableObject implements Transferable {
private Object obj;
private DataFlavor thisFlavor;
private ArrayList acceptedFlavors;
private Transferable defaultTransferableObject;
/**
* Creates a new instance of TransferableObject
*/
public TransferableObject(Object obj, DataFlavor[] acceptedFlavors, Transferable defaultTransferableObject) {
super();
this.obj = obj;
this.acceptedFlavors = toArrayList(acceptedFlavors);
this.thisFlavor = new DataFlavor(obj.getClass(), obj.getClass().getName());
if(!this.acceptedFlavors.contains(thisFlavor)) this.acceptedFlavors.add(thisFlavor);
this.defaultTransferableObject = defaultTransferableObject;
}
/**
* Creates a new instance of TransferableObject
*/
public TransferableObject(Object obj, ArrayList acceptedFlavors, Transferable defaultTransferableObject) {
super();
this.obj = obj;
this.acceptedFlavors = acceptedFlavors;
this.thisFlavor = new DataFlavor(obj.getClass(), obj.getClass().getName());
if(!this.acceptedFlavors.contains(thisFlavor)) this.acceptedFlavors.add(thisFlavor);
this.defaultTransferableObject = defaultTransferableObject;
}
public static ArrayList toArrayList(Object[] objects) {
ArrayList list = new ArrayList(objects.length);
for(int i=0; i<objects.length; ++i) {
list.add(objects[i]);
}
return list;
}
public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
System.out.println("[TransferableObject] <getTransferData> flavor: "+flavor);
System.out.println("[TransferableObject] <getTransferData> thisFlavor: "+thisFlavor);
if (flavor.equals(thisFlavor)) {
return obj;
}
return this.defaultTransferableObject.getTransferData(flavor);
}
/**
* @return Returns the object.
*/
public Object getObject() {
return this.obj;
}
public DataFlavor[] getTransferDataFlavors() {
DataFlavor[] fl = new DataFlavor[acceptedFlavors.size()];
for(int i=0; i<fl.length; ++i) {
fl[i] = (DataFlavor)acceptedFlavors.get(i);
}
return fl;
}
public boolean isDataFlavorSupported(DataFlavor flavor) {
return acceptedFlavors.contains(flavor);
}
/**
* @return Returns the defaultTransferableObject.
*/
public Transferable getDefaultTransferableObject() {
return this.defaultTransferableObject;
}
/**
* @return Returns the best Flavor of the transferable object.
*/
public DataFlavor getPreferredFlavor() {
return this.thisFlavor;
}
/**
* Util method that transform text into InputStream using a given DataFlavor.
* @param text The String to be exported
* @param flavor The DataFlavor that request the export.
* @return An InputStream containing the <code>text</code>
* @throws UnsupportedEncodingException ...
*/
public static InputStream exportAsInputStream(String text, DataFlavor flavor) throws UnsupportedEncodingException {
String charset = flavor.getMimeType().replaceFirst(".*charset=", "");
System.out.println("[TransferableObject] <exportAsInputStream> Charset: "+charset);
return new ByteArrayInputStream(text.getBytes(charset));
}
/**
* Util method that transform the transferable object from TextPlainUnicode to String.
* @param transferable The transferable object to be imported.
* @return The String representation of the transferable as TextPlainUnicode.
* @throws UnsupportedFlavorException ...
* @throws IOException ...
*/
public static String importAsInputStream(Transferable transferable) throws UnsupportedFlavorException, IOException {
BufferedReader sr = new BufferedReader(DataFlavor.getTextPlainUnicodeFlavor().getReaderForText(transferable));
String line = null;
String plainText = "";
while((line = sr.readLine()) != null) {
plainText += line;
}
return plainText;
}
}
Java
import java.io.File;
import groovy.lang.Binding;
import groovy.util.GroovyScriptEngine;
public class GroovyRunner {
/**
* Usage: GroovyRunner [groovy file]
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
if(args.length == 1) {
File groovyFile = new File(args[0]);
String[] roots = new String[] {groovyFile.getParentFile().getAbsolutePath()};
GroovyScriptEngine gse = new GroovyScriptEngine(roots);
Binding binding = new Binding();
binding.setVariable("args", roots);
gse.run(groovyFile.getName(), binding);
} else {
System.out.println("usage: "+GroovyRunner.class.getName()+" [groovy file]");
}
}
}
Java
