org.eclipse.ui.actions.ReadOnlyStateChecker#org.eclipse.swt.dnd.TransferData源码实例Demo

/**
 * This implementation of <code>javaToNative</code> converts plain text
 * represented by a java <code>String</code> to a platform specific
 * representation.
 * 
 * @param object
 *            a java <code>String</code> containing text
 * @param transferData
 *            an empty <code>TransferData</code> object; this object will
 *            be filled in on return with the platform specific format of
 *            the data
 * 
 * @see Transfer#javaToNative
 */
public void javaToNative( Object object, TransferData transferData )
{
	if ( checkText( object ) && isSupportedType( transferData ) )
	{
		try
		{
			super.javaToNative( ( (String) object ).getBytes( "UTF-8" ), //$NON-NLS-1$
					transferData );
		}
		catch ( UnsupportedEncodingException e )
		{
			// do not need to log
			super.javaToNative( ( (String) object ).getBytes( ),
					transferData );
		}
	}
}
 

@Override
public Object nativeToJava(TransferData transferData) {
	Object result = urlTransfer.nativeToJava(transferData);
	if (DISABLED || result != null) {
		return result;
	}

	if (DEBUG) System.out.println("nativeToJava called");
	try {
		if (isSupportedType(transferData)) {
			byte [] buffer = (byte[]) super.nativeToJava(transferData);
			return bytebufferToJava(buffer);
		}
	} catch (Exception e) {
		Debug.out(e);
	}

	return null;
}
 

/**
 * This implementation of <code>nativeToJava</code> converts a platform
 * specific representation of plain text to a java <code>String</code>.
 * 
 * @param transferData
 *            the platform specific representation of the data to be
 *            converted
 * @return a java <code>String</code> containing text if the conversion
 *         was successful; otherwise null
 * 
 * @see Transfer#nativeToJava
 */
public Object nativeToJava( TransferData transferData )
{
	if ( !isSupportedType( transferData ) )
	{
		return null;
	}
	byte[] bytes = (byte[]) super.nativeToJava( transferData );

	try
	{
		return new String( bytes, "UTF-8" ); //$NON-NLS-1$
	}
	catch ( UnsupportedEncodingException e )
	{
		// do not need to log
	}
	return new String( bytes );
}
 

/**
 * Retrieves Java import information from the clipboard.
 *
 * @return {@link JavaImportData} containing imports information
 */
public static JavaImportData getJavaImportsContent() {
	return clipboardOperation(new Function<Clipboard, JavaImportData>() {

		@Override
		public JavaImportData apply(Clipboard clipboard) {
			for (int i = 0; i < clipboard.getAvailableTypeNames().length; i++) {
				final String formatName = clipboard.getAvailableTypeNames()[i];
				if (formatName.startsWith("source-with-imports-transfer-format")) {
					final TransferData transferData = clipboard.getAvailableTypes()[i];
					Object content = clipboard.getContents(new DynamicByteArrayTransfer(formatName, transferData));
					if (content instanceof JavaImportData) {
						return (JavaImportData) content;
					}
					return null;
				}
			}
			return null;
		}
	});
}
 

@Override
public void javaToNative(Object object, TransferData transferData) {
    if (!checkMyType(object) || !isSupportedType(transferData)) {
        DND.error(DND.ERROR_INVALID_DATA);
    }
    MyDummyType2 myTypes = (MyDummyType2) object;
    try {
        // write data to a byte array and then ask super to convert to
        // pMedium
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream writeOut = new DataOutputStream(out);
        writeOut.writeInt(myTypes.dummy);
        byte[] buffer2 = out.toByteArray();
        writeOut.close();
        super.javaToNative(buffer2, transferData);
    } catch (IOException e) {
    }
}
 

@Override
public Object nativeToJava(TransferData transferData) {
    if (isSupportedType(transferData)) {
        byte[] buffer = (byte[]) super.nativeToJava(transferData);
        if (buffer == null)
            return null;

        MyDummyType2 datum = new MyDummyType2();
        try {
            ByteArrayInputStream in = new ByteArrayInputStream(buffer);
            DataInputStream readIn = new DataInputStream(in);
            datum.dummy = readIn.readInt();
            readIn.close();
        } catch (IOException ex) {
            return null;
        }
        return datum;
    }

    return null;
}
 

@Override
public void javaToNative(Object object, TransferData transferData) {
    if (!checkMyType(object) || !isSupportedType(transferData)) {
        DND.error(DND.ERROR_INVALID_DATA);
    }
    MyDummyType myTypes = (MyDummyType) object;
    try {
        // write data to a byte array and then ask super to convert to
        // pMedium
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream writeOut = new DataOutputStream(out);
        writeOut.writeInt(myTypes.dummy);
        byte[] buffer2 = out.toByteArray();
        writeOut.close();
        super.javaToNative(buffer2, transferData);
    } catch (IOException e) {
    }
}
 

@Override
public Object nativeToJava(TransferData transferData) {
    if (isSupportedType(transferData)) {
        byte[] buffer = (byte[]) super.nativeToJava(transferData);
        if (buffer == null)
            return null;

        MyDummyType datum = new MyDummyType();
        try {
            ByteArrayInputStream in = new ByteArrayInputStream(buffer);
            DataInputStream readIn = new DataInputStream(in);
            datum.dummy = readIn.readInt();
            readIn.close();
        } catch (IOException ex) {
            return null;
        }
        return datum;
    }

    return null;
}
 

@Override
protected void javaToNative(Object object, TransferData transferData)
{
	if (object instanceof SnippetElement)
	{
		SnippetElement snippetElement = (SnippetElement) object;
		byte[] bytes = getBytes(snippetElement);
		if (bytes != null)
		{
			super.javaToNative(bytes, transferData);
		}
	}
	else
	{
		super.javaToNative(object, transferData);
	}
}
 

@Override
protected Object nativeToJava(TransferData transferData) {
	/*
	 * The element serialization format is:
	 *  (int) number of element
	 * Then, the following for each element:
	 *  (String) handle identifier
	 */

	byte[] bytes= (byte[]) super.nativeToJava(transferData);
	if (bytes == null)
		return null;
	DataInputStream in= new DataInputStream(new ByteArrayInputStream(bytes));
	try {
		int count= in.readInt();
		IJavaElement[] results= new IJavaElement[count];
		for (int i= 0; i < count; i++) {
			results[i]= readJavaElement(in);
		}
		return results;
	} catch (IOException e) {
		return null;
	}
}
 

@Override
protected Object nativeToJava(TransferData transferData) {

	byte[] bytes = (byte[]) super.nativeToJava(transferData);
	if (bytes == null)
		return null;
	DataInputStream in = new DataInputStream(new ByteArrayInputStream(bytes));
	try {
		int count = in.readInt();
		TypedSource[] results = new TypedSource[count];
		for (int i = 0; i < count; i++) {
			results[i] = readJavaElement(in);
			Assert.isNotNull(results[i]);
		}
		in.close();
		return results;
	} catch (IOException e) {
		return null;
	}
}
 

/**
 * {@inheritDoc}
 */
@Override
protected int determineOperation(Object target, int operation, TransferData transferType, int operations) {

	boolean isPackageFragment= target instanceof IPackageFragment;
	boolean isJavaProject= target instanceof IJavaProject;
	boolean isPackageFragmentRoot= target instanceof IPackageFragmentRoot;
	boolean isContainer= target instanceof IContainer;

	if (!(isPackageFragment || isJavaProject || isPackageFragmentRoot || isContainer))
		return DND.DROP_NONE;

	if (isContainer) {
		IContainer container= (IContainer)target;
		if (container.isAccessible() && !Resources.isReadOnly(container))
			return DND.DROP_COPY;
	} else {
		IJavaElement element= (IJavaElement)target;
		if (!element.isReadOnly())
			return DND.DROP_COPY;
	}

	return DND.DROP_NONE;
}
 

@Override
protected int determineOperation(Object target, int operation, TransferData transferType, int operations) {
	setSelectionFeedbackEnabled(false);
	setExpandEnabled(false);

	initializeSelection();

	if (target != null) {
		return super.determineOperation(target, operation, transferType, operations);
	} else if (getInputElement(getSelection()) != null) {
		setSelectionFeedbackEnabled(false);
		setExpandEnabled(false);
		return operation == DND.DROP_DEFAULT || operation == DND.DROP_MOVE ? DND.DROP_LINK : operation;
	} else {
		return DND.DROP_NONE;
	}
}
 

@Override
public Object nativeToJava( TransferData transferData ) {
  byte bytes[] = (byte[]) super.nativeToJava( transferData );
  if ( bytes == null ) {
    return null;
  }
  long startTime = Long.parseLong( new String( bytes ) );
  return ( this.startTime == startTime ) ? item : null;
}
 

@Override
protected void javaToNative ( final Object object, final TransferData transferData )
{
    final byte[] bytes = toByteArray ( (Item[])object );
    if ( bytes != null )
    {
        super.javaToNative ( bytes, transferData );
    }
}
 

@Override
public Object nativeToJava ( final TransferData transferData )
{
    final byte[] bytes = (byte[])super.nativeToJava ( transferData );
    if ( bytes == null )
    {
        return null;
    }
    return fromByteArray ( bytes );
}
 

@Override
protected void javaToNative ( final Object object, final TransferData transferData )
{
    final byte[] bytes = toByteArray ( (Item[])object );
    if ( bytes != null )
    {
        super.javaToNative ( bytes, transferData );
    }
}
 

@Override
public TransferData[] getSupportedTypes() {
	if (DISABLED) {
		return urlTransfer.getSupportedTypes();
	}
	return super.getSupportedTypes();
}
 

public void javaToNative(Object object, TransferData transferData) {
	if (!checkMyType(object) || !isSupportedType(transferData)) {
		DND.error(DND.ERROR_INVALID_DATA);
	}
	String string = (String) object;
	byte[] bytes = string.getBytes();
	if (bytes != null) {
		super.javaToNative(bytes, transferData);
	}
}
 

/**
* @generated
*/
protected List getObjectsBeingDropped() {
	TransferData data = getCurrentEvent().currentDataType;
	HashSet<URI> uris = new HashSet<URI>();

	Object transferedObject = getJavaObject(data);
	if (transferedObject instanceof IStructuredSelection) {
		IStructuredSelection selection = (IStructuredSelection) transferedObject;
		for (Iterator<?> it = selection.iterator(); it.hasNext();) {
			Object nextSelectedObject = it.next();
			if (nextSelectedObject instanceof CrossflowNavigatorItem) {
				View view = ((CrossflowNavigatorItem) nextSelectedObject).getView();
				nextSelectedObject = view.getElement();
			} else if (nextSelectedObject instanceof IAdaptable) {
				IAdaptable adaptable = (IAdaptable) nextSelectedObject;
				nextSelectedObject = adaptable.getAdapter(EObject.class);
			}

			if (nextSelectedObject instanceof EObject) {
				EObject modelElement = (EObject) nextSelectedObject;
				uris.add(EcoreUtil.getURI(modelElement));
			}
		}
	}

	ArrayList<EObject> result = new ArrayList<EObject>(uris.size());
	for (URI nextURI : uris) {
		EObject modelObject = getEditingDomain().getResourceSet().getEObject(nextURI, true);
		result.add(modelObject);
	}
	return result;
}
 

@Override
public Object nativeToJava(TransferData transferData) {
	byte[] bytes = (byte[]) super.nativeToJava(transferData);
	if (bytes != null) {
		try {
			return new JavaImportData(new ClipboardData(bytes));
		} catch (IOException e) {
		}
	}
	return null;
}
 

@Override
protected void javaToNative(Object data, TransferData transferData) {
	if (data instanceof ClipboardData) {
		try {
			super.javaToNative(((ClipboardData) data).serialize(), transferData);
		} catch (IOException e) {
			//it's best to send nothing if there were problems
		}
	}
}
 

@Override
protected Object nativeToJava(TransferData transferData) {
	byte[] bytes = (byte[]) super.nativeToJava(transferData);
	if (bytes != null) {
		try {
			return new XbaseClipboardData(bytes);
		} catch (IOException e) {
		}
	}
	return null;
}
 

/**
 * Validate the drop. Invalidation is caused if
    * 
    * - outline is not uptodate
    * - transfer type is other than text
    * - drop target is equal or children of source
    * - target is preamble
    * 
    * @param target
    * @param operation
    * @param transferType
    * 
    * @return true if drop is valid
    * 
    * @see org.eclipse.jface.viewers.ViewerDropAdapter#validateDrop(java.lang.Object, int, org.eclipse.swt.dnd.TransferData)
 */
public boolean validateDrop(Object target, int operation,
		TransferData transferType) {

	// deny if outline is dirty
	if (this.outline.isModelDirty()) {
		return false;
	}
	
	// check transfer type, only allow text
	if (!TextTransfer.getInstance().isSupportedType(transferType)) {
		return false;
	}
			
	// get the selected node, check null and type
	OutlineNode targetNode = (OutlineNode)target;
	if (targetNode == null || targetNode.getType() == OutlineNode.TYPE_PREAMBLE) {
		return false;
	}
   
	// deny dropping over oneself or over ones children
	if (targetNode.equals(this.dragSource) ||
			isAncestor(dragSource, targetNode)) {
		return false;
	}
	
	return true;
}
 

@Override
public IStatus validateDrop(Object target, int operation, TransferData transferType) {
    if (target instanceof TmfTraceFolder) {
        return Status.OK_STATUS;
    }
    if (target instanceof TmfExperimentElement) {
        return Status.OK_STATUS;
    }
    if (target instanceof TmfTraceElement) {
        ITmfProjectModelElement parent = ((TmfTraceElement) target).getParent();
        if (parent instanceof TmfTraceFolder) {
            return Status.OK_STATUS;
        }
        if (parent instanceof TmfExperimentElement) {
            return Status.OK_STATUS;
        }
    }

    if (target instanceof TmfProjectElement) {
        return Status.OK_STATUS;
    }

    if (target instanceof IProject) {
        return Status.CANCEL_STATUS;
    }

    return Status.CANCEL_STATUS;
}
 

private boolean extractEventData(DropTargetEvent e) {
	TransferData transferData = e.currentDataType;
	if (transferData != null) {
		Object data = URLTransfer.getInstance().nativeToJava(transferData);
		if (data != null && getUrl(data) != null) {
			e.data = data;
			return true;
		}
	}
	return false;
}
 

public void javaToNative (Object object, TransferData transferData) {
	if (object == null || !(object instanceof ISVNRemoteResource)) return;
	
	if (isSupportedType(transferData)) {
		// write data to a byte array and then ask super to convert to pMedium
	byte[] buffer = toByteArray((ISVNRemoteResource) object);
    super.javaToNative(buffer, transferData);
	}
}
 

@Override
protected void javaToNative(Object data, TransferData transferData) {
	if (!(data instanceof IJavaElement[]))
		return;

	IJavaElement[] javaElements= (IJavaElement[]) data;
	/*
	 * The element serialization format is:
	 *  (int) number of element
	 * Then, the following for each element:
	 *  (String) handle identifier
	 */

	try {
		ByteArrayOutputStream out= new ByteArrayOutputStream();
		DataOutputStream dataOut= new DataOutputStream(out);

		//write the number of elements
		dataOut.writeInt(javaElements.length);

		//write each element
		for (int i= 0; i < javaElements.length; i++) {
			writeJavaElement(dataOut, javaElements[i]);
		}

		//cleanup
		dataOut.close();
		out.close();
		byte[] bytes= out.toByteArray();
		super.javaToNative(bytes, transferData);
	} catch (IOException e) {
		//it's best to send nothing if there were problems
	}
}
 

private Paster[] createEnabledPasters(TransferData[] availableDataTypes, Clipboard clipboard) {
	Paster paster;
	Shell shell = getShell();
	List<Paster> result= new ArrayList<Paster>(2);
	paster= new ProjectPaster(shell, clipboard);
	if (paster.canEnable(availableDataTypes))
		result.add(paster);

	paster= new JavaElementAndResourcePaster(shell, clipboard);
	if (paster.canEnable(availableDataTypes))
		result.add(paster);

	paster= new TypedSourcePaster(shell, clipboard);
	if (paster.canEnable(availableDataTypes))
		result.add(paster);

	paster= new FilePaster(shell, clipboard);
	if (paster.canEnable(availableDataTypes))
		result.add(paster);

	paster= new WorkingSetPaster(shell, clipboard);
	if (paster.canEnable(availableDataTypes))
		result.add(paster);

	paster= new TextPaster(shell, clipboard);
	if (paster.canEnable(availableDataTypes))
		result.add(paster);
	return result.toArray(new Paster[result.size()]);
}
 

protected final IResource[] getClipboardResources(TransferData[] availableDataTypes) {
	Transfer transfer= ResourceTransfer.getInstance();
	if (isAvailable(transfer, availableDataTypes)) {
		return (IResource[])getContents(fClipboard2, transfer, getShell());
	}
	return null;
}