public void javaToNative( Object object, TransferData transferData ) { if ( !checkMyType( object ) ) { return; // DND.error(DND.ERROR_INVALID_DATA); } try { byte[] buffer = Base64.encodeBase64( ( (DragAndDropContainer) object ).getXML().getBytes( Const.XML_ENCODING ) ); super.javaToNative( buffer, transferData ); } catch ( Exception e ) { log.logError( "Unexpected error trying to put a string onto the XML Transfer type: " + e.toString() ); log.logError( Const.getStackTracker( e ) ); return; } }
public Object nativeToJava( TransferData transferData ) { if ( isSupportedType( transferData ) ) { try { byte[] buffer = (byte[]) super.nativeToJava( transferData ); String xml = new String( Base64.decodeBase64( new String( buffer ).getBytes() ) ); return new DragAndDropContainer( xml ); } catch ( Exception e ) { log.logError( "Unexpected error trying to read a drag and drop container from the XML Transfer type: " + e.toString() ); log.logError( Const.getStackTracker( e ) ); return null; } } return null; }
/** * This implementation of <code>javaToNative</code> converts a java * <code>byte[]</code> to a platform specific representation. * * @param object a java <code>byte[]</code> containing the data to be * converted * @param transferData an empty <code>TransferData</code> object that will be * filled in on return with the platform specific format of the data * @see Transfer#nativeToJava */ public void javaToNative( Object object, TransferData transferData ) { if( !checkByteArray( object ) || !isSupportedType( transferData ) ) { DND.error( DND.ERROR_INVALID_DATA ); } byte[] data = ( byte[] )object; transferData.data = new byte[ data.length ]; System.arraycopy( data, 0, transferData.data, 0, data.length ); transferData.result = 1; }
@Override public boolean isSupportedType(TransferData transferData){ if (transferData == null) return false; int[] types = getTypeIds(); for (int i = 0; i < types.length; i++) { if (transferData.type == types[i]) return true; } return false; }
/** * This implementation of <code>nativeToJava</code> converts a platform * specific representation of a byte array to a java <code>byte[]</code>. * * @param transferData the platform specific representation of the data to be * converted * @return a java <code>byte[]</code> containing the converted data if the * conversion was successful; otherwise null * @see Transfer#javaToNative */ public Object nativeToJava( TransferData transferData ) { byte[] result = null; if( isSupportedType( transferData ) && ( transferData.data instanceof byte[] ) ) { byte[] data = ( byte[] )transferData.data; result = new byte[ data.length ]; System.arraycopy( data, 0, result, 0, data.length ); } return result; }
if (!isSupportedType(transferData) || transferData.pIDataObject == 0) return null; STGMEDIUM stgmedium = new STGMEDIUM(); stgmedium.tymed = COM.TYMED_HGLOBAL; transferData.result = getData(data, formatetc, stgmedium); data.Release(); if (transferData.result != COM.S_OK) return null;
/** * This implementation of <code>javaToNative</code> converts a java * <code>byte[]</code> to a platform specific representation. * * @param object a java <code>byte[]</code> containing the data to be converted * @param transferData an empty <code>TransferData</code> object that will * be filled in on return with the platform specific format of the data * * @see Transfer#nativeToJava */ protected void javaToNative (Object object, TransferData transferData) { if (!checkByteArray(object) && !isSupportedType(transferData)) { DND.error(DND.ERROR_INVALID_DATA); } byte[] orig = (byte[])object; NSData data = NSData.dataWithBytes(orig, orig.length); transferData.data = data; }
@Override public boolean isSupportedType(TransferData transferData){ if (transferData == null) return false; int[] types = getTypeIds(); for (int i = 0; i < types.length; i++) { if (transferData.type == types[i]) return true; } return false; }
/** * This implementation of <code>nativeToJava</code> converts a platform specific * representation of a byte array to a java <code>byte[]</code>. * * @param transferData the platform specific representation of the data to be converted * @return a java <code>byte[]</code> containing the converted data if the conversion was * successful; otherwise null * * @see Transfer#javaToNative */ @Override protected Object nativeToJava(TransferData transferData) { if ( !isSupportedType(transferData) || transferData.pValue == 0) return null; int size = transferData.format * transferData.length / 8; if (size == 0) return null; byte[] buffer = new byte[size]; OS.memmove(buffer, transferData.pValue, size); return buffer; }
@Override protected Object nativeToJava(TransferData transferData) { byte bytes[] = (byte[]) super.nativeToJava(transferData); return Arrays.equals(mCurrentID, bytes) ? mObject : null; }
/** * Overrides org.eclipse.swt.dnd.ByteArrayTransfer#javaToNative(Object, * TransferData). * Only encode the transfer type name since the selection is read and * written in the same process. * * @see org.eclipse.swt.dnd.ByteArrayTransfer#javaToNative(java.lang.Object, org.eclipse.swt.dnd.TransferData) */ @Override public void javaToNative(Object object, TransferData transferData) { byte[] check = TYPE_NAME.getBytes(); super.javaToNative(check, transferData); }
/** * This implementation of <code>javaToNative</code> converts a java * <code>byte[]</code> to a platform specific representation. * * @param object a java <code>byte[]</code> containing the data to be converted * @param transferData an empty <code>TransferData</code> object that will * be filled in on return with the platform specific format of the data * * @see Transfer#nativeToJava */ @Override protected void javaToNative (Object object, TransferData transferData) { transferData.result = 0; if (!checkByteArray(object) || !isSupportedType(transferData)) { DND.error(DND.ERROR_INVALID_DATA); } byte[] buffer = (byte[])object; if (buffer.length == 0) return; int /*long*/ pValue = OS.g_malloc(buffer.length); if (pValue == 0) return; OS.memmove(pValue, buffer, buffer.length); transferData.length = buffer.length; transferData.format = 8; transferData.pValue = pValue; transferData.result = 1; }
@Override public boolean isSupportedType(TransferData transferData){ if (transferData == null) return false; int[] types = getTypeIds(); for (int i = 0; i < types.length; i++) { if (transferData.type == types[i]) return true; } return false; }
/** * This implementation of <code>nativeToJava</code> converts a platform specific * representation of a byte array to a java <code>byte[]</code>. * * @param transferData the platform specific representation of the data to be converted * @return a java <code>byte[]</code> containing the converted data if the conversion was * successful; otherwise null * * @see Transfer#javaToNative */ @Override protected Object nativeToJava(TransferData transferData) { if ( !isSupportedType(transferData) || transferData.pValue == 0) return null; int size = transferData.format * transferData.length / 8; if (size == 0) return null; byte[] buffer = new byte[size]; OS.memmove(buffer, transferData.pValue, size); return buffer; }
@Override protected Object nativeToJava(TransferData transferData) { Object result= super.nativeToJava(transferData); if (!(result instanceof byte[]) || !TYPE_NAME.equals(new String((byte[]) result))) return null ; return fObject ; } }
public void javaToNative(final Object object, final TransferData transferData) { final byte[] check = TYPE_NAME.getBytes(); super.javaToNative(check, transferData); }
/** * This implementation of <code>javaToNative</code> converts a java * <code>byte[]</code> to a platform specific representation. * * @param object a java <code>byte[]</code> containing the data to be converted * @param transferData an empty <code>TransferData</code> object that will * be filled in on return with the platform specific format of the data * * @see Transfer#nativeToJava */ @Override protected void javaToNative (Object object, TransferData transferData) { transferData.result = 0; if (!checkByteArray(object) || !isSupportedType(transferData)) { DND.error(DND.ERROR_INVALID_DATA); } byte[] buffer = (byte[])object; if (buffer.length == 0) return; int /*long*/ pValue = OS.g_malloc(buffer.length); if (pValue == 0) return; OS.memmove(pValue, buffer, buffer.length); transferData.length = buffer.length; transferData.format = 8; transferData.pValue = pValue; transferData.result = 1; }
public boolean isSupportedType(TransferData transferData){ if (transferData == null) return false; int[] types = getTypeIds(); for (int i = 0; i < types.length; i++) { if (transferData.type == types[i]) return true; } return false; }
/** * This implementation of <code>nativeToJava</code> converts a platform specific * representation of a byte array to a java <code>byte[]</code>. * * @param transferData the platform specific representation of the data to be converted * @return a java <code>byte[]</code> containing the converted data if the conversion was * successful; otherwise null * * @see Transfer#javaToNative */ @Override protected Object nativeToJava(TransferData transferData) { if ( !isSupportedType(transferData) || transferData.pValue == 0) return null; int size = transferData.format * transferData.length / 8; if (size == 0) return null; byte[] buffer = new byte[size]; OS.memmove(buffer, transferData.pValue, size); return buffer; }
@Override protected Object nativeToJava(TransferData transferData) { Object result= super.nativeToJava(transferData); if (!(result instanceof byte[]) || !TYPE_NAME.equals(new String((byte[]) result))) return null ; return fObject ; } }